BestCoder #58 div1

2015-10-08 19:14:54

总结：赛后补的一场。题目蛮有意思的。

A：DFS

思路：搜一下几个环然后判断一下即可。

#include <cstdio>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;

#define getmid(l,r) ((l) + ((r) - (l)) / 2)
#define MEM(a,b) memset(a,b,sizeof(a))
#define MP(a,b) make_pair(a,b)
#define PB push_back

typedef long long ll;
typedef pair<int,int> pii;
const double eps = 1e-;
const int INF = ( << ) - ;
const int MAXN = ;

int T;
int n,ans,cnt;
int A[MAXN],B[MAXN],pos[MAXN];
int vis[MAXN];

void Dfs(int p){
    if(vis[p]) return;
    cnt++;
    vis[p] = ;
    Dfs(pos[p]);
}

int main(){
    scanf("%d",&T);
    while(T--){
        MEM(vis,);
        scanf("%d",&n);
        for(int i = ; i <= n; ++i) scanf("%d",A + i);
        for(int i = ; i <= n; ++i){
            int a;
            scanf("%d",&a);
            B[A[i]] = a;
            pos[a] = A[i];
        }
        ans = ;
        for(int i = ; i <= n; ++i) if(vis[i] == ){
            cnt = ;
            Dfs(i);
            if(cnt == ) ans++;
            else ans += cnt - ;
        }
        printf("%d\n",ans);
    }
    return ;
}

B：DP

题意：给出n个数，算出所有子序列去掉连续相同数（只保留一个）后的总和。

思路：总的思路就是总数 - 重复的计数。我们可以枚举每个数，算出其贡献，比如对于第i个数vi。先算左边的数，可取可不取，但是与vi相同的数一定不取，方案数为L，同理算出右边的方案数（算右边时可以取与vi相同的数），那么贡献就是vi×L×R。

#include <cstdio>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;

#define getmid(l,r) ((l) + ((r) - (l)) / 2)
#define MEM(a,b) memset(a,b,sizeof(a))
#define MP(a,b) make_pair(a,b)
#define PB push_back

typedef long long ll;
typedef pair<int,int> pii;
const double eps = 1e-;
const int INF = ( << ) - ;
const int MAXN = ;
const ll mod = 1e9 + ;

int T;
int n,A[MAXN];
ll pw[MAXN],pre[MAXN],val[MAXN];
map<int,ll> S1;

int main(){
    pw[] = pre[] = ;
    for(int i = ; i <= ; ++i){
        pw[i] = pw[i - ] * 2LL % mod;
        pre[i] = (pre[i - ] + pw[i]) % mod;
    }
    scanf("%d",&T);
    while(T--){
        S1.clear();
        scanf("%d",&n);
        for(int i = ; i <= n; ++i)
            scanf("%d",A + i);
        for(int i = ; i <= n; ++i){
            if(i == ) val[i] = ;
            else val[i] = ( + pre[i - ] - S1[A[i]]) % mod;
            val[i] = (val[i] + mod) % mod;
            S1[A[i]] += pw[i - ];
        }
        for(int i = n - ; i >= ; --i){
            val[i] = (val[i] * ( + pre[n - i - ])) % mod;
        }
        ll ans = ;
        for(int i = ; i <= n; ++i){
            ans = (ans + A[i] * val[i] % mod) % mod;
        }
        printf("%lld\n",ans);
    }
    return ;
}

C：树状数组

题意：n个数删除连续的m个数，算出最小逆序数。

思路：用两个树状数组模拟一个删除框即可。

#include <cstdio>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;

#define getmid(l,r) ((l) + ((r) - (l)) / 2)
#define MEM(a,b) memset(a,b,sizeof(a))
#define MP(a,b) make_pair(a,b)
#define PB push_back

typedef long long ll;
typedef pair<int,int> pii;
const double eps = 1e-;
const int INF = ( << ) - ;
const int MAXN = ;

int T,n,m;
int A[MAXN],fk[][MAXN];

void Update(int id,int x,int d){
    while(x <= n){
        fk[id][x] += d;
        x += x & (-x);
    }
}

int Getsum(int id,int x){
    int res = ;
    while(x){
        res += fk[id][x];
        x -= x & (-x);
    }
    return res;
}

int main(){
    scanf("%d",&T);
    while(T--){
        MEM(fk,);
        scanf("%d%d",&n,&m);
        for(int i = ; i <= n; ++i) scanf("%d",A + i);
        ll inv = ;
        for(int i = m + ; i <= n; ++i){
            inv += (i - m - ) - Getsum(,A[i]);
            Update(,A[i],);
        }
        ll ans = inv;
        // fk0 : pre , fk1 : suf
        for(int i = ; i + m <= n; ++i){
            inv -= (i - ) - Getsum(,A[i + m]);
            inv -= Getsum(,A[i + m] - );
            Update(,A[i + m],-);
            inv += (i - ) - Getsum(,A[i]);
            inv += Getsum(,A[i] - );
            Update(,A[i],);
            ans = min(ans,inv);
        }
        printf("%lld\n",ans);
    }
    return ;
}

D：DP+矩阵快速幂+生成树计数

思路：q轮选出n-1条边（构成一棵树）的方案数为cnt。对于每个生成树，构成其的方案数都是cnt。用dp[i][j]表示i轮选了j种边的方案数，转移方程：dp[i][j] = dp[i - 1][j - 1] * (n - j) + dp[i - 1][j] * j 用矩阵快速幂算出cnt。下面就是生成树计数，算出生成树种类num，那么答案就是cnt × num。

#include <cstdio>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;

#define getmid(l,r) ((l) + ((r) - (l)) / 2)
#define MEM(a,b) memset(a,b,sizeof(a))
#define MP(a,b) make_pair(a,b)
#define PB push_back

typedef long long ll;
typedef pair<int,int> pii;
const double eps = 1e-;
const int INF = ( << ) - ;
const int MAXN = ;

int T,n,m,p,q,mod;
int D[MAXN][MAXN],G[MAXN][MAXN];

ll Det(int n){
    ll A[MAXN][MAXN];
    for(int i = ; i <= n; ++i)
        for(int j = ; j <= n; ++j)
            A[i][j] = D[i][j];
    ll res = ;
    for(int i = ; i <= n; ++i){
        for(int j = i + ; j <= n; ++j){
            while(A[j][i]){
                ll t = A[i][i] / A[j][i];
                 for(int k = i; k <= n; ++k)
                     A[i][k] = (A[i][k] - A[j][k] * t) % mod;
                 for(int k = i; k <= n; ++k)
                     swap(A[i][k],A[j][k]);
                 res = -res;
            }
        }
        if(!A[i][i]) return ;
        res = res * A[i][i] % mod;
    }
    return (res + mod) % mod;
}

struct Mx{
    ll a[MAXN][MAXN];
    void clear(){ MEM(a,); }
    void stand(){ clear(); for(int i = ; i <= n; ++i) a[i][i] = ; }
    Mx operator * (const Mx &b){
        Mx c; c.clear();
        for(int k = ; k <= n; ++k)
        for(int i = ; i <= n; ++i)
        for(int j = ; j <= n; ++j){
            c.a[i][j] = (c.a[i][j] + a[i][k] * b.a[k][j]) % mod;
        }
        return c;
    }
};

Mx t;

Mx Q_pow(int v){
    Mx res; res.stand();
    while(v){
        if(v & ) res = res * t;
        t = t * t;
        v >>= ;
    }
    return res;
}

int main(){
    scanf("%d",&T);
    while(T--){
        MEM(D,);
        MEM(G,);
        scanf("%d%d%d%d",&n,&m,&p,&q);
        mod = p;
        for(int i = ; i <= m; ++i){
            int a,b;
            scanf("%d%d",&a,&b);
            D[a][a]++;
            D[b][b]++;
            G[a][b] = G[b][a] = ;
        }
        for(int i = ; i <= n; ++i)
            for(int j = ; j <= n; ++j)
                D[i][j] -= G[i][j];
        ll val = Det(n - );
        //structure Mx t
        t.clear();
        for(int i = ; i <= n; ++i){
            t.a[i][i] = i;
            t.a[i][i - ] = n - i;
        }
        Mx ans; ans.clear();
        ans.a[][] = n - ;
        ans = Q_pow(q - ) * ans;
        printf("%lld\n",(val * ans.a[n - ][]) % mod);
    }
    return ;
}