幸运数字 I
定义一个数字为幸运数字当且仅当它的所有数位都是4或者7。
比如说，47、744、4都是幸运数字而5、17、467都不是。
现在，给定一个字符串s，请求出一个字符串，使得：
1、它所代表的整数是一个幸运数字；
2、它非空；
3、它作为s的子串（不是子序列）出现了最多的次数（不能为0次）。
请求出这个串（如果有多解，请输出字典序最小的那一个）。
s中无4或7，输出-1
4的个数大于等于7，输出4
否则输出7
幸运数字 II
定义一个数字为幸运数字当且仅当它的所有数位都是4或者7。
比如说，47、744、4都是幸运数字而5、17、467都不是。
定义next(x)为大于等于x的第一个幸运数字。
给定l，r，请求出
next(l) + next(l + 1) + ... + next(r - 1) + next(r)
生成幸运数字，顺序排列，二分求next(x)，累加不同的next值即可。
注意：
-
因为l最大可以为1000,000,000，所以幸运数字最少生成到4444,444,444才行
-
生成方法有二：
采用队列，每次出队元素为x，入队x10+4, x10+7;
next_permutation生成所有排列，下面代码使用这种方法。
-
生成的元素不多，可直接使用数组保存，并用lower_bound查找。这里使用的是set，因为set就是一棵平衡二叉树（红黑树），其自带二分功能。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
set<ll> A;
void init()
{
for(int nd = 1; nd <= 10; ++nd) {
for(int n4 = nd; n4 >= 0; --n4) {
int n7 = nd - n4;
string ns = string(n4, '4') + string(n7, '7');
while(next_permutation(ns.begin(), ns.end()))
A.insert(atoll(ns.c_str()));
A.insert(atoll(ns.c_str()));
}
}
}
int main()
{
init();
ll a, b, ans = 0;
cin >> a >> b;
ll cur = a;
while(cur <= b) {
ll next = *A.lower_bound(cur);
ans += (min(next, b) - cur + 1) * next;
cur = next + 1;
}
cout << ans << endl;
}
幸运数字 III
定义一个数字为幸运数字当且仅当它的所有数位都是4或者7。
比如说，47、744、4都是幸运数字而5、17、467都不是。
假设现在有一个数字d，现在想在d上重复k次操作。
假设d有n位，用d1,d2,...,dn表示。 对于每次操作，我们想要找到最小的
x (x < n)，使得dx=4并且dx+1=7。
如果x为奇数，那么我们把dx和dx+1都变成4；
否则，如果x为偶数，我们把dx和dx+1都变成7；
如果不存在x，那么我们不做任何修改。
现在请问k次操作以后，d会变成什么样子。
首先，笨的方法，肯定会循环，所以求循环节的长度，但字符串很长，所以hash。
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, k;
char str[maxn];
map<unsigned, unsigned> Next;
unsigned Hash(char *s)
{
unsigned hashval = 0;
while(*s)
hashval = *s++ + 31 * hashval;
return hashval;
}
void operate()
{
for(int i = 1; str[i]; ++i) {
if(str[i] == '7' && str[i-1] == '4') {
str[i] = str[i-1] = (i & 1) ? '4' : '7';
break;
}
}
}
int loopLength(unsigned start)
{
int cnt = 0;
unsigned p = start;
do {
++cnt;
p = Next[p];
} while(p != start);
return cnt;
}
int main()
{
scanf("%d%d%s", &n, &k, str);
unsigned curHash = Hash(str);
if(n == 1 || k == 0) {
printf("%s\n", str);
} else {
while(k > 0) {
//cout << str << " " << curHash << endl;
operate();
if(Next[curHash]) {
for(k = (k+1) % loopLength(curHash); k > 0; --k)
operate();
break;
} else {
curHash = Next[curHash] = Hash(str);
--k;
}
}
printf("%s\n", str);
}
}
聪明的方法，什么时候会循环，如何循环？
O为Odd奇数，E为Even偶数，考虑以下片段：
下标: ...OEO...
内容: ...477...
...447...
...477...
循环节为2，同理有以下片段：
下标: ...OEO...
内容: ...447...
...477...
...447...
所以就有代码如下：
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, k;
char s[maxn];
int main()
{
scanf("%d%d%s", &n, &k, s + 1);
for(int i = 1; i < n && k; ++i) {
if(s[i] == '4' && s[i+1] == '7') {
if(i & 1) {
if(s[i+2] == '7') k %= 2;
if(k) s[i+1] = '4', --k;
} else {
if(s[i-1] == '4') k %= 2;
if(k) s[i] = '7', --k;
}
}
}
printf("%s\n", s+1);
}
幸运数字 IV
定义一个数字为幸运数字当且仅当它的所有数位都是4或者7。
比如说，47、744、4都是幸运数字而5、17、467都不是。
1..n的第k小排列中，多少个幸运数字所在的位置的序号也是幸运数字。
考虑到13! > 1e9，所以在前k < 1e9小的排列中，只有最后13位会被改变。
所以在[1, n-13]中数字和下标是相等的，可直接判断；
[n-12, n]这段可通过康托展开求第k小排列来判断。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n, k, fac[14];
vector<ll> A;
void init()
{
fac[0] = 1;
for(int i = 1; i < 14; ++i)
fac[i] = fac[i-1] * i;
for(int nd = 1; nd <= 9; ++nd) {
for(int n4 = nd; n4 >= 0; --n4) {
int n7 = nd - n4;
string ns = string(n4, '4') + string(n7, '7');
while(next_permutation(ns.begin(), ns.end()))
A.push_back(atoll(ns.c_str()));
A.push_back(atoll(ns.c_str()));
}
}
sort(A.begin(), A.end());
}
bool isLucky(ll x)
{
if(!x) return false;
for(; x; x /= 10)
if(x % 10 != 4 && x % 10 != 7)
return false;
return true;
}
int solve()
{
int cnt = 0;
bool vis[14] = {0};
if(n < 14 && k > fac[n])
return -1;
// [1, n-13] 不会重排，所以数字和下标一样，计算有多少幸运数即可
if(n >= 14)
cnt += upper_bound(A.begin(), A.end(), n-13) - A.begin();
// [f, t] 计算这个片段的第k小排列，判断有多少合法的
ll f = max(1LL, n-12), t = n;
--k;
for(ll i = 0, lim = t-f+1; i < lim; ++i) {
ll j, rank = k / fac[lim-i-1];
for(j = f; j <= t; ++j) {
if(vis[j-f]) continue;
if(rank-- <= 0) break;
}
cnt += isLucky(f+i) && isLucky(j);
k %= fac[lim-i-1];
vis[j-f] = 1;
}
return cnt;
}
int main()
{
init();
cin >> n >> k;
cout << solve() << endl;
}
乌龟跑步
有一只乌龟，初始在0的位置向右跑。
乌龟会依次接到一串指令，指令T表示向后转，指令F表示向前移动一个单位。
乌龟不能忽视任何指令。
现在我们要修改其中正好n个指令
求这只乌龟在结束的时候离起点的最远距离。
一个指令可以被改多次，一次修改定义为把某一个T变成F或把某一个F变成T
假设乌龟最后的位置为x，我们想要abs(x)最大，输出最大的abs(x)
f[i][j][k][p]代表：
前i个字符，执行j次操作，能否达k位置，且此时头朝向p侧(0左1右)
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[105];
bool f[105][55][210][2];
int main()
{
scanf("%s%d", s+1, &m);
n = strlen(s+1);
f[0][0][100][1] = 1;
for(int i = 1; i <= n; ++i) {
for(int j = 0; j <= m; ++j) {
for(int k = 0; k <= 200; ++k) {
if(s[i] == 'F') {
// 将当前'F'变为'T'，改变朝向
if(j) f[i][j][k][1] |= f[i-1][j-1][k][0];
if(j) f[i][j][k][0] |= f[i-1][j-1][k][1];
// 不改变当前'F'，继续前进
f[i][j][k+1][1] |= f[i-1][j][k][1];
f[i][j][k-1][0] |= f[i-1][j][k][0];
} else {
// 将当前'T'变为'F'，继续前进
if(j) f[i][j][k+1][1] |= f[i-1][j-1][k][1];
if(j) f[i][j][k-1][0] |= f[i-1][j-1][k][0];
// 不改变当前'T'，改变朝向
f[i][j][k][1] |= f[i-1][j][k][0];
f[i][j][k][0] |= f[i-1][j][k][1];
}
}
}
}
int ans = 0;
for(int i = 0; i <= 200 ; ++i) {
if(f[n][m][i][0]) ans = max(ans, abs(100-i));
if(f[n][m][i][1]) ans = max(ans, abs(100-i));
}
printf("%d\n", ans);
}
m皇后
在一个n*n的国际象棋棋盘上有m个皇后。
一个皇后可以攻击其他八个方向的皇后
（上、下、左、右、左上、右上、左下、右下）。
对于某个皇后，如果某一个方向上有其他皇后，那么这个方向
对她就是不安全的。 对于每个皇后，
我们都能知道她在几个方向上是不安全的。
现在我们想要求出t0,t1,...,t8，
其中ti表示恰有i个方向是"不安全的"的皇后有多少个。
分别按水平、垂直、主对角线、负对角线排序4次；
每次排好后，正反遍历两次，以求所有8个方向是否安全。
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m;
int cnt[maxn], ans[10];
struct Point { int x, y, i; } ps[maxn];
// from left to right
bool horizontal(const Point &p1, const Point &p2)
{
return (p1.y == p2.y) ? p1.x < p2.x : p1.y < p2.y;
}
// from top to bottom
bool vertical(const Point &p1, const Point &p2)
{
return (p1.x == p2.x) ? p1.y < p2.y : p1.x < p2.x;
}
// from top-left to bottom-right
bool mainDiagonal(const Point &p1, const Point &p2)
{
return (p1.x-p1.y != p2.x-p2.y) ?
(p1.x-p1.y < p2.x-p2.y) : (p1.x < p2.x);
}
bool onSameMainDiagonal(const Point &p1, const Point &p2)
{
return p1.x-p1.y == p2.x-p2.y;
}
// from bottom-left to top-right
bool subDiagonal(const Point &p1, const Point &p2)
{
return (p1.x+p1.y != p2.x+p2.y) ?
(p1.x+p1.y < p2.x+p2.y) : (p1.x < p2.x);
}
bool onSameSubDiagonal(const Point &p1, const Point &p2)
{
return p1.x+p1.y == p2.x+p2.y;
}
int main()
{
ios::sync_with_stdio(false);
cin >> n >> m;
for(int i = 0; i < m; ++i) {
cin >> ps[i].x >> ps[i].y;
ps[i].i = i;
}
sort(ps, ps+m, horizontal);
for(int i = 1; i < m; ++i) // to right
if(ps[i-1].y == ps[i].y) ++cnt[ps[i].i];
for(int i = m-2; i >= 0; --i) // to left
if(ps[i+1].y == ps[i].y) ++cnt[ps[i].i];
sort(ps, ps+m, vertical);
for(int i = 1; i < m; ++i) // to bottom
if(ps[i-1].x == ps[i].x) ++cnt[ps[i].i];
for(int i = m-2; i >= 0; --i) // to top
if(ps[i+1].x == ps[i].x) ++cnt[ps[i].i];
sort(ps, ps+m, mainDiagonal);
for(int i = 1; i < m; ++i) // to bottom-right
if(onSameMainDiagonal(ps[i-1], ps[i])) ++cnt[ps[i].i];
for(int i = m-2; i >= 0; --i) // to top-left
if(onSameMainDiagonal(ps[i+1], ps[i]))
++cnt[ps[i].i];
sort(ps, ps+m, subDiagonal);
for(int i = 1; i < m; ++i) // to top-right
if(onSameSubDiagonal(ps[i-1], ps[i])) ++cnt[ps[i].i];
for(int i = m-2; i >= 0; --i) // to bottom-left
if(onSameSubDiagonal(ps[i+1], ps[i])) ++cnt[ps[i].i];
for(int i = 0; i < m; ++i)
++ans[cnt[i]];
cout << ans[0];
for(int i = 1; i < 9; ++i)
cout << " " << ans[i];
cout << endl;
}