2020SEERC

这场难度很大，打起来比较吃力。

B. Reverse Game

题意：

给定一个01串，两人轮流翻转10，100，110，1010，这四种子串，无法进行操作则失败。

博弈论题，不会做，队友写的。

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 1000010;
 
char s[maxn];
 
vector<int> pos;
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> s + 1;
	int i, ans = 0, n = strlen(s + 1), num = 0;
	for(i = 1; i <= n ; i++){
		if(s[i] == '1') {
			ans += (n - num - i);
			num++;
		}
	}
	if (ans % 3) cout << "Alice" << endl;
	else cout << "Bob" << endl;
	return 0;
}

E. Divisible by 3

题意：

给定一个长度为n序列，问有多少连续子序列中两两相乘的和能被3整除。

dp，dp[i][j][k]表示以i为末尾，子段和模3为j,子段的weight模3为k的子段数量。九种状态直接转移即可。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
#include <iostream>
#include <string>
#define debug(x) cout << #x << ": " << (x) << "\n";
using namespace std;
typedef long long ll;
const int maxn = 5e5 + 10;
const int maxm = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
ll dp[maxn][3][3];
int n;
ll a[maxn];

int main()
{
    scanf("%d", &n);
    for ( int i = 1;i <= n;i++ ) {
        scanf("%lld", &a[i]);
        a[i] %= 3;
        dp[i][0][a[i]]++;
    }
    for ( int i = 1;i <= n;i++ ) {
        for ( int j = 0;j <= 2;j++ ) {
            for ( int k = 0;k <= 2;k++ ) {
                ll x = (j + a[i] * k) % 3;
                ll y = (a[i] + k) % 3;
                dp[i][x][y] += dp[i - 1][j][k];
            }
        }
    }
    ll ans = 0;
    for ( int i = 1;i <= n;i++ ) {
        for ( int j = 0;j <= 2;j++ ) {
            ans += dp[i][0][j];
        }
    }
    printf("%lld", ans);
    return 0;
}

I. Modulo Permutations

题意：

问1 ~ n的全排列中有多少对于任意i都满足 。

显然1和2可以放在任意位置，问题便转化为3 ~ n分成两组单调递减的序列，并满足有多少方案。dp[i]表示一段以i结尾，另一段以i - 1结尾的方案数，然后枚举 i - 1的倍数及其 +1，+2。最后答案再乘n即可。复杂度由调和级数知为。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
#include <iostream>
#include <string>
#define debug(x) cout << #x << ": " << (x) << "\n";
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 10;
const int maxm = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
const int p = 1e9 + 7;
ll dp[maxn];

int main()
{
    int n;
    scanf("%d", &n);
    if ( n == 1 ) {
        printf("1\n");
        return 0;
    }
    if ( n == 2 ) {
        printf("2\n");
        return 0;
    }
    for ( int i = n;i >= 4;i-- ) {
        dp[i] = 1;
        int temp = 2 * i - 2;
        dp[i] = (dp[i] + dp[i + 1]) % p;
        while ( temp <= n ) {
            dp[i] = (dp[i] + dp[temp]) % p;
            if ( temp + 1 <= n )
                dp[i] = (dp[i] + dp[temp + 1]) % p;
            if ( temp + 2 <= n )
                dp[i] = (dp[i] + dp[temp + 2]) % p;
            temp += i - 1;
        }
    }
    for ( int i = 4;i <= n;i++ ) {
        dp[2] = (dp[2] + dp[i]) % p;
    }
    dp[2] = (2 * dp[2] + 2) % p;
    printf("%lld\n", dp[2] * n % p);
    return 0;
}

/*1 1 2 4 8 16 28 48 76 120*/

L. Neo-Robin Hood

题意：

有n个人，每个人有元并且希望得到元，你可以选择偷他们的钱或帮助他们，每当你偷了一个人，都需要帮助一个人来掩盖此次偷窃行为，求最多可以偷多少人。

假设答案为k，那么一定也帮助了正好k个人。考虑两个人i和j，若偷i帮助j的收益更大，则有即。那么我们按照a+b的大小排序。

接下来二分答案，判断是否可行。若当前二分到k，那么我们维护一个小根堆和一个大根堆，分别计算第i个位置前选择k个人进行帮助需要花费的最少代价和第i个位置后选择k个人进行偷窃所能得到的最大收益，若存在，即为可行。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
#include <iostream>
#include <string>
#define debug(x) cout << #x << ": " << (x) << "\n";
using namespace std;
typedef long long ll;
const int maxn = 3e5 + 10;
const int maxm = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
struct TT {
    ll a, b;
    bool operator<(const TT& x)const
    {
        return a + b < x.a + x.b;
    }
}a[maxn << 1];
int n;
ll dp1[maxn], dp2[maxn];

bool check(int x)
{
    priority_queue<int> pq1;
    priority_queue<int, vector<int>, greater<int> > pq2;
    memset(dp1, 0, sizeof dp1);
    memset(dp2, 0, sizeof dp2);
    for ( int i = 1;i <= x;i++ ) {
        pq1.push(a[i].b);
        dp1[x] += a[i].b;
    }
    for ( int i = x + 1;i <= n;i++ ) {
        if ( pq1.top() > a[i].b ) {
            dp1[i] = dp1[i - 1] - pq1.top() + a[i].b;
            pq1.pop();
            pq1.push(a[i].b);
        }
        else dp1[i] = dp1[i - 1];
    }
    for ( int i = n;i >= n - x + 1;i-- ) {
        pq2.push(a[i].a);
        dp2[n - x + 1] += a[i].a;
    }
    for ( int i = n - x;i >= 1;i-- ) {
        if ( pq2.top() < a[i].a ) {
            dp2[i] = dp2[i + 1] - pq2.top() + a[i].a;
            pq2.pop();
            pq2.push(a[i].a);
        }
        else dp2[i] = dp2[i + 1];
    }
    int flag = 0;
    for ( int i = x;i <= n - x;i++ ) {
        if ( dp2[i + 1] - dp1[i] >= 0 ) {
            flag = 1;
        }
    }
    return flag;
}

int main()
{
    scanf("%d", &n);
    for ( int i = 1;i <= n;i++ ) {
        scanf("%lld", &a[i].a);
    }
    for ( int i = 1;i <= n;i++ ) {
        scanf("%lld", &a[i].b);
    }
    if ( n == 1 ) {
        printf("0\n");
        return 0;
    }
    sort(a + 1, a + n + 1);
    int l = 0, r = n / 2 + 1;
    int ans = 0;
    while ( l < r ) {
        int mid = (l + r) >> 1;
        if ( mid == 0 ) {
            ans = 0;
            break;
        }
        if ( mid > n / 2 )
            break;
        if ( check(mid) ) {
            l = mid + 1;
            ans = mid;
        }
        else {
            r = mid;
        }
    }
    printf("%d", ans);
    return 0;
}

M. Mistake

题意：

给定一个n*k的操作，输出每个操作是第几轮执行的。

直接用一个桶记录当前操作是第几次出现，直接输出即可。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
#include <iostream>
#include <string>
#define debug(x) cout << #x << ": " << (x) << "\n";
using namespace std;
typedef long long ll;
const int maxn = 5e5 + 10;
const int maxm = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
struct Edge {
    int to, next;
}e[maxn << 2];
int head[maxn], tot;
int n, k, m;
int a[maxn], b[maxn];
int num[maxn];

void addedge(int u, int v)
{
    e[++tot] = Edge({ v,head[u] });
    head[u] = tot;
}

int main()
{
    scanf("%d%d%d", &n, &k, &m);
    for ( int i = 1;i <= m;i++ ) {
        scanf("%d%d", &a[i], &b[i]);
        addedge(a[i], b[i]);
    }
    int tt;
    for ( int i = 1;i <= n * k;i++ ) {
        scanf("%d", &tt);
        printf("%d ", ++num[tt]);
    }
    return 0;
}