Bestcoder Round #73 (div.2)

http://acm.hdu.edu.cn/showproblem.php?pid=5630
题意：
黑白相间棋盘，每次可以对一个矩形的格子进行取反，问想要达到颜色都一样最少几次？
思路：
首先，如果先对偶数行取反，再对偶数列取反，可以得到一个[n/2]+[m/2][n/2] + [m/2][n/2]+m/2的解, 只要说明这个这是答案的下界就可以了。 考虑第一列，每次操作最多使得两个第一列的相邻元素变得一样， 第一列有n−1n-1n−1对相邻元素,这样使得第一列变成一样的次数就是[(n−1)/2][(n-1)/2](n−1)/2，同理考虑第一行即可!

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n,m,t;cin>>t;
    while(t--){
        scanf("%d%d",&n,&m);
        printf("%d\n",n/2+m/2);
    }
}

http://acm.hdu.edu.cn/showproblem.php?pid=5631
题意：
n个点，n+1条边，问有多少种情况使得至少删掉1条边后，整个图仍然联通。
思路：
让 nnn 个点联通最少需要 n−1n-1n−1 条边，所以最多只能删除两条边，我们可以枚举删除的这两条边（或者唯一的一条边），然后暴力BFS判断连通性就好了。时间复杂度 O(n^3)！

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<iostream>
using namespace std;
int T,n,ans;
int u[105],v[105],b[105],f[105];
int getf(int x){return f[x]?f[x]=getf(f[x]):x;}
int merge(int x,int y)
{
    x=getf(x),y=getf(y);
    if(x!=y)return f[x]=y,1;
    return 0;
}
int check()
{
    memset(f,0,n+1<<2);
    int pn=n;
    for(int i=0;i<=n;i++)
        if(!b[i])
            pn-=merge(u[i],v[i]);
    return pn==1;
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        ans=0;
        for(int i=0;i<=n;i++)
            scanf("%d%d",u+i,v+i);
        for(int i=0;i<=n;i++)
        {
            b[i]=1;
            ans+=check();
            for(int j=i+1;j<=n;j++)
            {
                b[j]=1;
                ans+=check();
                b[j]=0;
            }
            b[i]=0;
        }
        cout<<ans<<endl;
    }
    return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=5632

很明显这是一道数位DP的题目，状态 dp[i][j][k]dp[i][j][k]dp[i][j][k] 表示当前考虑了最高的 iii 位，两个数目前数位和的差是 jjj，当前两个数以及给定的 nnn 之间的大小关系是 kkk，然后暴力枚举这两个数的当前位的值，然后转移就好了。时间复杂度 O(log^2 n)

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<queue>
#include<set>
#define mo 998244353
#define maxn 1010 
#define fr first
#define sc second
#define mp make_pair
#define pb push_back
#define son e[i].t
#define pow POW
#define clear(x) memset(x, 0, sizeof(x))
typedef long long ll;
using namespace std;
int T, n;
int cnt[maxn][maxn], sum[maxn][maxn], f[maxn];
int o[maxn], a[maxn], len, tmp;
char s[maxn];
bool divide()
{
    if (o[1] % 2) a[len] = 1, o[1] --; ++ len;
    for (int i = tmp; i >= 1; -- i){
        if (o[i] % 2 == 0)
            o[i] /= 2; 
        else{
            o[i - 1] += 10;
            o[i] = (o[i] - 1) / 2;
        }
    }
    while (tmp && ! o[tmp]) -- tmp;
    return tmp > 0;
}
int now[maxn];
void solve()
{
    clear(a);
    scanf("%s", s + 1); tmp = strlen(s + 1); len = 0;
    for (int i = 1; i <= tmp; ++ i) o[i] = s[tmp - i + 1] - '0';
    o[1] = o[1] + 1;
    while (divide());
    clear(now);
    int tot = 0, ans = 0;
    for (int i = len; i >= 0; -- i){
        if (a[i]){
            for (int j = tot + 1; j <= 1000; ++ j) 
                ans = (ans + 1ll * now[j] * sum[i][j - tot - 1] % mo) % mo;
            for (int j = tot; j <= 1000; ++ j)
                now[j] = (now[j] + cnt[i][j - tot]) % mo;
            ++ tot;
            ans = (ans + f[i]) % mo;
        }
    }
    printf("%d\n", ans);
}
int main()
{
    cnt[0][0] = 1;
    for (int i = 0; i <= 1000; ++ i) sum[0][i] = 1;
    f[1] = 0;
    for (int i = 1; i <= 1000; ++ i){
        cnt[i][0] = cnt[i - 1][0];
        for (int j = 1; j <= 1000; ++ j)
            cnt[i][j] = (cnt[i - 1][j - 1] + cnt[i - 1][j]) % mo;
        sum[i][0] = cnt[i][0];
        for (int j = 1; j <= 1000; ++ j) sum[i][j] = (sum[i][j - 1] + cnt[i][j]) % mo;
        f[i + 1] = 2ll * f[i] % mo;
        for (int j = 2; j <= 1000; ++ j) f[i + 1] = (f[i + 1] + 1ll * cnt[i][j] * sum[i][j - 2] % mo) % mo;
    }
    scanf("%d", &T);
    while (T --) solve();
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <deque>
#include <stack>
#include <queue>
#include <algorithm>

using namespace std;
const int maxn = 1100;
const int modu = 998244353;

string op , ne;
int a[maxn] , cnt;

int id(char c) { return c-'0'; }
char reid(int c) { return c+'0'; }
void turn()
{
    cnt = 0;
    while(true)
    {
        if(op=="1")
        {
            a[++cnt] = id(op[0]);
            break;
        }

        if(id(op[op.size()-1])%2) a[++cnt] = 1; else a[++cnt] = 0;
        int last = 0 , now;
        for(int i=0;i<op.size();i++)
        {    
            now = last*10+id(op[i]);
            if(now%2) last = 1; else last = 0;
            if(i || now/2) ne += reid(now/2);
        }
        op = ne; ne="";
    }
    reverse(a+1, a+1+cnt);
}

int d[maxn][maxn*2][2][2];

void up(int& a , int b) { a = (a+b)%modu; }

int main(int argc, char *argv[]) {

    int t , n;
    cin>>t;

    while(t--)
    {
        cin>>op;
        turn();

        n = cnt;
        for(int i=0;i<=n;i++) for(int j=0;j<=2*n;j++) for(int k=0;k<2;k++) for(int l=0;l<2;l++) 
            d[i][j][k][l] = 0;

        d[0][n][1][1] = 1;
        for(int i=0;i<n;i++) for(int j=0;j<=2*n;j++) for(int k=0;k<2;k++) for(int l=0;l<2;l++)
        {
            int& now = d[i][j][k][l];

            if(!now) continue;
            int jj , kk , ll;
            for(int x=0;x<2;x++) for(int y=0;y<2;y++)
            {
                if(k && x>a[i+1]) continue;
                if(l && x<y) continue;

                jj = j+x-y;
                if(k && x==a[i+1]) kk = 1; else kk = 0;
                if(l && x==y) ll = 1; else ll = 0;

                up(d[i+1][jj][kk][ll], now);
            }
        }

        int res = 0;
        for(int i=n-1;i>=0;i--) for(int k=0;k<2;k++) up(res, d[n][i][k][0]);
        cout<<res<<endl;
    }

    return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=5634
注意到10^7​​ 之内的数最多phi O(log(n))O(log(n)) 次就会变成11， 因此可以考虑把一段相同的不为11的数缩成一个点，用平衡树来维护。每次求phi的时候就在平衡树上取出这个区间然后暴力求phi，如果一段数变成了11，就在平衡树里面删掉它，最后统计答案的时候只要把区间中被删去的11加回答案即可，时间复杂度O((n + m)logn)

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
const int N = 1e7, L = 7e5, T = 3e5 + 10;
bool used[N + 10];
int phi[N + 10], p[L];
int a[T], flag[T << 2];
long long sum[T << 2];
int len, t, n, m;
void getprime()
{
    phi[1] = 1;
    for(int i = 2; i <= N; ++i)
    {
        if(! used[i])
        {
            p[++len] = i;
            phi[i] = i - 1;
        }
        for(int j = 1; j <= len && i * p[j] <= N; ++j)
        {
            used[i * p[j]] = 1;
            if(i % p[j] == 0)
            {
                phi[i * p[j]] = phi[i] * p[j];
                break;
            }
            else
                phi[i * p[j]] = phi[i] * (p[j] - 1);
        }
    }
}
void build(int x, int L, int R)
{
    if(L == R)
    {
        sum[x] = flag[x] = a[L];
        return;
    }
    int mid = (L + R) >> 1;
    build(x << 1, L, mid);
    build(x << 1 | 1, mid + 1, R);
    sum[x] = sum[x << 1] + sum[x << 1 | 1];
    flag[x] = (flag[x << 1] == flag[x << 1 | 1] ? flag[x << 1] : 0);
}
void update2(int x, int L, int R, int tl, int tr, int y)
{
    if(L <= tl && tr <= R)
    {
        flag[x] = y;
        sum[x] = (long long)flag[x] * (tr - tl + 1);
        return;
    }
    int mid = (tl + tr) >> 1;
    if(flag[x])
    {
        update2(x << 1, tl, mid, tl, mid, flag[x]);
        update2(x << 1 | 1, mid + 1, tr, mid + 1, tr, flag[x]);
    }
    if(L <= mid)
        update2(x << 1, L, R, tl, mid, y);
    if(mid < R)
        update2(x << 1 | 1, L, R, mid + 1, tr, y);
    sum[x] = sum[x << 1] + sum[x << 1 | 1];
    flag[x] = (flag[x << 1] == flag[x << 1 | 1] ? flag[x << 1] : 0);
}
void update1(int x, int L, int R, int tl, int tr)
{
    if(flag[x] && L <= tl && tr <= R)
    {
        flag[x] = phi[flag[x]];
        sum[x] = (long long)flag[x] * (tr - tl + 1);
        return;
    }
    int mid = (tl + tr) >> 1;
    if(flag[x])
    {
        update2(x << 1, tl, mid, tl, mid, flag[x]);
        update2(x << 1 | 1, mid + 1, tr, mid + 1, tr, flag[x]);
    }
    if(L <= mid)
        update1(x << 1, L, R, tl, mid);
    if(mid < R)
        update1(x << 1 | 1, L, R, mid + 1, tr);
    sum[x] = sum[x << 1] + sum[x << 1 | 1];
    flag[x] = (flag[x << 1] == flag[x << 1 | 1] ? flag[x << 1] : 0);
}
long long query(int x, int L, int R, int tl, int tr)
{
    if(L <= tl && tr <= R)
        return sum[x];
    int mid = (tl + tr) >> 1;
    if(flag[x])
    {
        update2(x << 1, tl, mid, tl, mid, flag[x]);
        update2(x << 1 | 1, mid + 1, tr, mid + 1, tr, flag[x]);
    }
    long long re = 0;
    if(L <= mid)
        re += query(x << 1, L, R, tl, mid);
    if(mid < R)
        re += query(x << 1 | 1, L, R, mid + 1, tr);
    return re;
}
int main()
{
    getprime();
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; ++i)
            scanf("%d", &a[i]);
        build(1, 1, n);
        int op, x, y, z;
        while(m--)
        {
            scanf("%d%d%d", &op, &x, &y);
            if(op == 1)
                update1(1, x, y, 1, n);
            else if(op == 2)
            {
                scanf("%d", &z);
                update2(1, x, y, 1, n, z);
            }
            else
                printf("%I64d\n", query(1, x, y, 1, n));
        }
    }
    return 0;
}