UESTC 2016 Summer Training #19 Div.2（未完待续）

题目来源：
https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&category=643
2014 Asia Jakarta Regional Contest
UVALive 6906 - 6916

A

B
题意：
给出一个哑铃图的定义. 一个图中分成点个数相等的两堆,每堆内部是一个完全图.堆与堆之间只有一条边相连. 现在给出一个图,不一定联通. 看它的每一个联通块是不是我们的哑铃图. 输出满足哑铃图的个数.

题解：
法一:用桥来判断. 哑铃图一定只有一个桥吗?发现只有一个特例,两边是2个点的时候都是桥. 其他情况有且只有一个桥. 那么有一个桥的一定是哑铃图吗?还要求桥的两边点数一样,并且边数是一个定值.用度来统计就好了.
所以就是先dfs tarjan找一下桥,找到桥之后看两边的点数和度数判定.额外的是4个点的特判.
法二:只从度的角度来判断.发现特殊的两个点的度数是比其他的都多1的.并且其他的点的度数都是确定的.那么我们判定一下先仅有两个特殊的度点.然后从其中的一个点,刨去另一个点不能跑,只跑一边去染色,然后先看度满足情况.之后再看每个点是不是只和自己颜色的染过.

///////////代码是判定桥的.#include <cstdio>#include <cstring>#include <algorithm>#include <vector>using namespace std;const int N = 1e3;int n,m;int vis[N];int dfn[N],low[N],in[N];int key[10010],to;vector <int> g[N];int flag = 0;int cnt = 0,cn = 0;int dfs(int u,int f,int len){    cn += in[u];    vis[u] = 1;    low[u] = len;    dfn[u] = len;    int tot = 0;    for (int i = 0;i < g[u].size();i++)    {        int v = g[u][i];        if (v == f) continue;        if (vis[v] == 0)        {            int tmp = dfs(v,u,len+1);            tot += tmp;            if (low[v] > dfn[u])                key[++to] = tmp;            low[u] = min(low[v],low[u]);        }        else            low[u] = min(dfn[v],low[u]);    }    return tot + 1;}int main(){    int t;    scanf("%d",&t);    while (t--)    {        memset(vis,0,sizeof vis);        memset(in,0,sizeof in);        scanf("%d %d",&n,&m);        for (int i = 1;i <= n;i++) g[i].clear();        int ans = 0;        for (int i = 1;i <= m;i++)        {            int x,y;            scanf("%d %d",&x,&y);            in[x]++;in[y]++;            g[y].push_back(x);            g[x].push_back(y);        }        for (int i = 1;i <= n;i++)        if (vis[i] == 0)        {            cnt = cn = to = 0;            cnt = dfs(i,0,1);            if (cnt & 1) continue;            if (cn & 1) continue;            int flag2 = 0;            cnt /= 2;            for (int i = 1;i <= to;i++)                if (key[i] == cnt) flag2 = 1;            if (flag2 == 1 && cn/2 == 1 + cnt*(cnt-1)) ans++;        }        static int ca = 0;        printf("Case #%d: %d\n",++ca,ans);    }}

C
题意:
给定N≤103个障碍物，和一辆车，变挡次数K≤10，车的电量E≤50，车有4挡，耗电为挡数，不同的挡提供不同的额外能量
能量不足以提供车当前挡前进的时候，车直接就报废了。问穿过所有的障碍物人的最少能量花费？
分析:
赤果果的dp
dp[i][k][e][l]:=第几个障碍物，剩余变挡次数，剩余能量，当前挡数，人的最小能量花费，由于状态1000∗10∗50∗4=2e6比较大，乘case数=100就T了
用队列优化一下就好了，类似于spfa的感觉

////  Created by TaoSama on 2015-12-21//  Copyright (c) 2015 TaoSama. All rights reserved.////#pragma comment(linker, "/STACK:1024000000,1024000000")#include <algorithm>#include <cctype>#include <cmath>#include <cstdio>#include <cstdlib>#include <cstring>#include <iomanip>#include <iostream>#include <map>#include <queue>#include <string>#include <set>#include <vector>using namespace std;#define pr(x) cout << #x << " = " << x << "  "#define prln(x) cout << #x << " = " << x << endlconst int N = 1e3 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;int n, k, e, ans;int h[N], f[N][11][51][4];bool in[N][11][51][4];int power[] = {0, 4, 8, 11};struct Sta {    int p, c, e, l; //position, chance, energy, level};void see(Sta u, Sta v) {    int &cur = f[u.p][u.c][u.e][u.l];    int &nxt = f[v.p][v.c][v.e][v.l];    printf("f[%d][%d][%d][%d] = %d → ", u.p, u.c, u.e, u.l, cur);    printf("f[%d][%d][%d][%d] = %d\n", v.p, v.c, v.e, v.l, nxt);}void spfa() {    queue<Sta> q;    memset(f, 0x3f, sizeof f);    memset(in, false, sizeof in);    f[0][k][e][0] = 0; in[0][k][e][0] = true;    q.push((Sta) {0, k, e, 0});    while(q.size()) {        Sta u = q.front(); q.pop();        in[u.p][u.c][u.e][u.l] = false;        int &cur = f[u.p][u.c][u.e][u.l];        if(u.p == n) {            ans = min(ans, cur);            continue;        }        if(u.c) {            for(int i = 0; i < 4; ++i) {                if(i == u.l || u.e < i) continue;                Sta v = u;                ++v.p; --v.c; v.e -= i; v.l = i;                int cost = max(0, h[v.p] - power[v.l]);                int &nxt = f[v.p][v.c][v.e][v.l];                if(nxt > cur + cost) {                    nxt = cur + cost;//                  see(u, v);                    if(!in[v.p][v.c][v.e][v.l]) {                        in[v.p][v.c][v.e][v.l] = true;                        q.push(v);                    }                }            }        }        Sta v = u; ++v.p;        if(v.e < v.l) v.c = v.e = v.l = 0; //lack energy, just set 0        else v.e -= v.l;        int cost = max(0, h[v.p] - power[v.l]);        int &nxt = f[v.p][v.c][v.e][v.l];        if(nxt > cur + cost) {            nxt = cur + cost;            if(!in[v.p][v.c][v.e][v.l]) {                in[v.p][v.c][v.e][v.l] = true;                q.push(v);            }        }    }}int main() {#ifdef LOCAL    freopen("C:\\Users\\TaoSama\\Desktop\\in.txt", "r", stdin);//  freopen("C:\\Users\\TaoSama\\Desktop\\out.txt","w",stdout);#endif    ios_base::sync_with_stdio(0);    int t; scanf("%d", &t);    while(t--) {        scanf("%d%d%d", &n, &k, &e);        for(int i = 1; i <= n; ++i) scanf("%d", h + i);        ans = INF;        spfa();        static int kase = 0;        printf("Case #%d: %d\n", ++kase, ans);    }    return 0;}

D

/* *  组合数学 *  题意： *      有N(500)个人，编号1~N，忽略前K(1<=K<N)的单调性，求使P(1<=P<=N)为第一个数小于前一个数或者最后一个数的 *      排列方案数。 *  思路： *      根据样例可知，上升序列从第K位开始计算。 *      [   K-1   ][   上升序列   ] P [   任意   ] *      或 *      [   K-1   ][   上升序列，P   ] *      对于排列1，需要枚举上升序列的长度，记为L(1<=L<=N-K), *      因为P小于前一个数，所以L必然含有[P+1,N]的数，记为I(1<=I<=min(N-P,L)) *        那么方案数：∑∑C(N-P,I)*C(P-1,L-I)*P(N-1-L),剩下N-1-L个数任意排列 *        对于排列2，因为后半段是上升序列，所以[P+1,N]必需全部放入K-1中， *        方案数：C(K-1,N-P)*P(N-P)*C(P-1,K-1-(N-P))*P(K-1-(N-P)) */#include<cstdio>#include<cstring>#include<cmath>#include<set>#include<algorithm>using namespace std;#define LL long long#define N 507#define MOD 1000000007LL a[N];LL c[N][N];void init(){    LL i,j;    // A    a[0]=1;    for(i=1;i<N;++i) a[i]=(a[i-1]*i)%MOD;    // C    for(i=0;i<N;++i)    for(j=0;j<=i;++j)    if(j==0 || j==i){        c[i][j]=1;    }    else{        c[i][j]=(c[i-1][j-1]+c[i-1][j])%MOD;    }}int main(){    int T,tt=0;    int n,m,p;    int i,j;    LL ans;    init();    scanf("%d",&T);    while(T--){        scanf("%d%d%d",&n,&m,&p);        ans=0;        // end        if(n-p<m){//            ans=a[n-p]*c[p-1][m-1-(n-p)]%MOD*a[m-1-(n-p)]%MOD;            ans=c[m-1][n-p]*a[n-p]%MOD*c[p-1][m-1-(n-p)]%MOD*a[m-1-(n-p)]%MOD;        }        // between        for(j=1;j<=n-m;++j){            for(i=1;i<=min(n-p,j);++i){                ans=(ans+c[n-p][i]*c[p-1][j-i]%MOD*a[n-1-j]%MOD)%MOD;            }        }        printf("Case #%d: %lld\n",++tt,ans);    }    return 0;}

E
别人的解法：
【题意】：
给出多棵树和两类操作：操作（C x）删除结点 x 与其父结点的连边；操作（Q a b）询问 a b 是否连通。
【解题思路】：
连通性的查询容易想到用并查集，关键在于如何处理删边。
考虑到删边的难点在于查询时的路径压缩导致某些结点与其父结点”不直接相连”，这里使用离线处理，在查询之前把所有该删的边删除，同时逆序处理询问操作；当逆序处理到删边操作时，复原删掉的边（删除变为增边）。
【代码】：（上了个比较标准的并查集模板）

#include<iostream>#include<cstdio>#include<cstring>#include<cmath>#include<stack>#include<algorithm>#define LL long long#define maxn 25000#define IN freopen("in.txt","r",stdin);using namespace std;struct Union_Find_Set{    int fa[maxn];    /*每个结点的父亲节点编号*/    int rank[maxn];    /*树的高度*/    /*构造并查集并初始化*/    void make_set()    {        for(int i=0; i<maxn; i++){            fa[i] = i;    /*初始时本身构成一个集合，根为本身*/            rank[i] = 0;        }    }    /*递归查找结点所在树的根节点*/    int find_set(int x)    {        /*路径压缩*/        return x!=fa[x]? fa[x]=find_set(fa[x]) : x;    }    /*合并两个集合*/    void unite_set(int x, int y)    {        x = find_set(x);        y = find_set(y);        /*记录树的高度防止合并后退化，rank小的向rank大的连接*/        if(rank[x] < rank[y]) swap(x,y);        fa[y] = x;    /*合并*/        if(rank[x] == rank[y]) rank[x]++;    /*高度相同则加1*/    }    /*判断两结点是否属于同一集合*/    bool same_set(int x, int y)    {        return find_set(x) == find_set(y);    }}UFS;int n,q;struct node{    char type;    int first, second;};stack<node> s;stack<bool> ans;int main(int argc, char const *argv[]){    //IN;    int t,ca=1;scanf("%d",&t);    while(t--)    {        scanf("%d %d",&n,&q);        while(!s.empty()) s.pop();        while(!ans.empty()) ans.pop();        UFS.make_set();        for(int i=1; i<=n; i++){            scanf("%d",&UFS.fa[i]);            if(!UFS.fa[i]) UFS.fa[i] = i;        }        for(int i=1; i<=q; i++)        {            node tmp_node;            getchar();            scanf("%c",&tmp_node.type);            if(tmp_node.type=='Q'){                scanf("%d %d",&tmp_node.first, &tmp_node.second);            }            else{                scanf("%d",&tmp_node.first);                tmp_node.second = UFS.fa[tmp_node.first];                /*离线处理--询问之前删边,避免路径压缩导致删边失效*/                UFS.fa[tmp_node.first] = tmp_node.first;            }            s.push(tmp_node);        }        while(q--)        {            node tmp_node = s.top(); s.pop();            if(tmp_node.type=='Q'){                if(UFS.same_set(tmp_node.first, tmp_node.second)) ans.push(1);                else ans.push(0);            }            else{                UFS.fa[tmp_node.first] = tmp_node.second;            }        }        printf("Case #%d:\n", ca++);        while(!ans.empty())        {            if(ans.top() == 1) puts("YES");            else puts("NO");            ans.pop();        }    }    return 0;}

我的做法：
由于输入只是给了每个点的父亲节点，套用并查集的思想，但是不进行路径压缩，按照题意模拟即可。

#include <bits/stdc++.h>#define _ ios_base::sync_with_stdio(0);cin.tie(0);#define INF 0x3f3f3f3f#define eps 1e-6typedef long long LL;const double pi = acos(-1.0);const long long mod = 1e9 + 9;using namespace std;const int MAX = 20005;int p[MAX];int Find(int x){    return p[x] == x ? x : Find(p[x]);}int main(){    ios_base::sync_with_stdio(false); cin.tie(0);    //freopen("int.txt","r",stdin);    //freopen("out.txt","w",stdout);    int cnt = 0;    int T;    cin >> T;    while(T--)    {        printf("Case #%d:\n",++cnt);        int N,K;        cin >> N >> K;        int x;        for(int i = 1;i <= N;i++)        {            cin >> x;            if(x == 0)                p[i] = i;            else                p[i] = x;        }        char s[5];        for(int i = 0;i < K;i++)        {            cin >> s;            int a,b;            if(s[0] == 'Q')            {                cin >> a >> b;                int u = Find(a);                int v = Find(b);                if(u != v)                    puts("NO");                else                    puts("YES");            }            else            {                cin >> x;                p[x] = x;            }        }    }    return 0;}

F

G

/* *    数论 *    题意： *        给N(<=1000)盏灯，和K(<=1000)个质数。起初每盏灯都是暗的，每个质数可以改变位置是其倍数的灯的状态（暗变亮、亮 *        变暗），求最多能点亮多少盏灯。 *    思路： *        如果两个质数会改变同一盏灯，那么满足a*b<=n。 *        通过这个式子，可以发现，如果质数x和y均大于sqrt(n)，那么x、y不会冲突（就是x选了，选y不会影响x点的灯）。 *        而N才1000，[sqrt(N)] = 31， *        不大于31的质数：2、3、5、7、11、13、17、19、23、29、31共11个。 *        对于大于sqrt(n)的数，取不取该数取决于小于sqrt(n)的数。 *        所以对于前11个质数，枚举其状态（取或不取）。 *        剩下的数则根据取之后会不会使答案更优来决定其状态。 */#include<cstdio>#include<cstring>#include<cmath>#include<set>#include<algorithm>using namespace std;#define N 1007int n,m,p,ans;int a[N];int st[N];set<int> g;set<int>::iterator it;void dfs(int t){    int i;    if(t>=p){        int j,cnt;        for(i=t;i<m;++i){            cnt=0;            for(j=a[i];j<=n;j+=a[i]){                cnt+=1-(st[j]<<1);            }            if(cnt>0){                for(j=a[i];j<=n;j+=a[i]) st[j]^=1;            }        }        cnt=0;        for(j=1;j<=n;++j) cnt+=st[j];        ans=max(ans,cnt);        return ;    }    // yes    for(i=a[t];i<=n;i+=a[t]) st[i]^=1;    dfs(t+1);    for(i=a[t];i<=n;i+=a[t]) st[i]^=1;    // no    dfs(t+1);}int main(){    int T,tt=0;    int i,x;    scanf("%d",&T);    while(T--){        scanf("%d%d",&n,&m);        g.clear();        for(i=0;i<m;++i){            scanf("%d",&x);            g.insert(x);        }        p=g.size();        x=sqrt((double)n);        for(it=g.begin(),m=0;it!=g.end();++it,++m){            a[m]=*it;            if(a[m]>x) p=min(p,m);        }        ans=0;        memset(st,0,sizeof(st));        dfs(0);        printf("Case #%d: %d\n",++tt,ans);    }    return 0;}

H

I

/* * 状压DP * 题意： * 在一个N*M(N,M<=8)矩阵，最多放K(K<=N*M)个障碍 * 求不存在从(1,1)到(N,M)的矩阵个数(只能向下或向右移动)。 * 思路： * 因为最大就8*8，所以考虑状压DP。 * 用1表示存在从(1,1)到当前位置的路径，0则表示不存在。 * 假设前i-1行的状态pre,当前行i的状态now, * 那么就可以转移出前i行与(1,1)的联通状态。 * 因为最多只能放k个，所以用f[i][j][k]表示前i行， * 放置j个障碍后，与(1,1)联通状态为k的方案数。 * ans=∑f[n][1~k][st],其中st&2^(m-1)==0(即(n,m)与(1,1)不联通) * #include<cstdio>#include<cstring>#include<algorithm>using namespace std;#define N 260#define MOD 1000000007int n,m,k;int s[N];int g[N][N];int f[10][70][N];int calc(int pre,int now){    int i,j,res=pre&now;    for(i=0;i<m;++i)    if((pre&(1<<i)) && (now&(1<<i))){        for(j=i+1;j< m && (now&(1<<j))>0;++j) res|=(1<<j);    }    return res;}void init(){    int i,j;    for(i=0;i<(1<<m);++i){        s[i]=0;        for(j=0;j<m;++j)        if(!(i&(1<<j))){            ++s[i];        }    }    for(i=0;i<(1<<m);++i)    for(j=0;j<(1<<m);++j){        g[i][j]=calc(i,j);    }}int main(){    int T,tt=0;    int i,j,pre,now,sta;    scanf("%d",&T);    while(T--){        scanf("%d%d%d",&n,&m,&k);        memset(f,0,sizeof(f));        init();        f[0][0][1]=1;        for(i=1;i<=n;++i){            for(now=0;now<(1<<m);++now)            for(j=s[now];j<=k;++j){                for(pre=0;pre<(1<<m);++pre){                    sta=g[pre][now];                    f[i][j][sta]+=f[i-1][j-s[now]][pre];                    if(f[i][j][sta]>=MOD) f[i][j][sta]-=MOD;                }            }        }        int ans=0;        for(i=1;i<=k;++i)        for(j=0;j<(1<<m);++j)        if(!(j&(1<<(m-1)))){            ans+=f[n][i][j];            if(ans>=MOD) ans-=MOD;        }        printf("Case #%d: %d\n",++tt,ans);    }    return 0;}

J

K

/* *    DP、取模 *    题意： *        从N*M(N,M<=10^6)的(1,1)向右和向下走到(N,M)的路径数，其中某些3*3的格子不能走(3*3的矩阵<=10)，结果数对997取模。 *    思路： *        当没有障碍的时候，方案数为C(N+M-2,N-1)(即总共走N-1+M-1步，其中N-1步向下走) *        假设只有1个障碍，那么就要从原方案中去掉包含该障碍的方案数，记该障碍的坐标为(x,y), *        则不合法的方案为C(x-1+y-1,x-1)*C(N-x+M-y,N-x) *        令f[i]表示从(1,1)出发到(x[i],y[i])的合法路径数， *        则f[j]=C(x[j]-1+y[j]-1,x[j]-1)-∑C(x[j]-x[i]+y[j]-y[i],x[j]-x[i]),其中x[i]<=x[j]&&y[i]<=y[j] *        结果需要对997取模，对于组合数C(n,m)=n!/(m!(n-m)!)，通过逆元和快速幂得到。 *        但是997可能比N、M小，导致比997大的阶乘均为0。 *        这样导致的问题是某些组合数不包含997，但是由于阶乘均为0，导致结果就为0了。 *        所以对于阶乘的预处理中要去掉997，另开数组记录997的指数。 *    问题： *        做的时候DP作法对了，但是没有意识到997导致的问题。 */#include<cstdio>#include<cstring>#include<algorithm>using namespace std;#define N 107#define M 2000007#define MOD 997int dx[]={-1,-1,-1,0,1,1,1,0};int dy[]={-1,0,1,1,1,0,-1,-1};int f[N];int P[M],G[M];struct Node{    int x,y;    bool operator<(const Node &p) const{        return x<p.x || (x==p.x && y<p.y);    }}    a[N];void init(){    int i,j;    P[0]=1;G[0]=0;    for(i=1;i<M;++i){        G[i]=G[i-1];        j=i;        while(j%MOD==0){            ++G[i];            j/=MOD;        }        P[i]=(j%MOD*P[i-1])%MOD;    }}int pow(int a,int b){    a%=MOD;    int res=1;    while(b>0){        if(b&1) res=(res*a)%MOD;        a=(a*a)%MOD;        b>>=1;    }    return res;}int work(int x,int y){    int res=P[x+y]*pow(P[x]*P[y],MOD-2)%MOD;    res=(res*pow(MOD,G[x+y]-G[x]-G[y]))%MOD;    return res;}void add(int &t,int x,int y){    a[t].x=x,a[t].y=y,++t;}int main(){    int T,tt=0;    int n,m,k,i,j,t,r,c;    init();    scanf("%d",&T);    while(T--){        scanf("%d%d%d",&n,&m,&k);        t=0;        add(t,1,1);        add(t,n,m);        for(i=0;i<k;++i){            scanf("%d%d",&r,&c);            for(j=0;j<8;++j){                add(t,r+dx[j],c+dy[j]);            }        }        sort(a,a+t);        f[0]=1;        for(i=1;i<t;++i){            f[i]=work(a[i].x-1,a[i].y-1);            for(j=1;j<i;++j)            if(a[j].x<=a[i].x && a[j].y<=a[i].y){                f[i]=(f[i]+MOD-f[j]*work(a[i].x-a[j].x,a[i].y-a[j].y)%MOD)%MOD;            }        }        printf("Case #%d: %d\n",++tt,f[t-1]);    }    return 0;}