牛客练习赛13

幸运数字 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;
}