Codeforces Round #302 (Div. 1) 训练

链接：

http://codeforces.com/contest/543

过程：

惨淡的只做出了A和C

题解：

A

题解：

简单的一道题

我们用$dp[i][j]$表示当前考虑到前num个人（这个另外枚举），当前写了$i$行代码，当前的bug数量为$j$的方案数

然后转移就是$dp[i][j]=sum {dp[i-1][j-a[num]]}$

Code：

#include<stdio.h>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<cmath>
#include<iostream>
#include<queue>
#include<string>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<long long,long long> pll;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define rep(i,j,k)  for(register int i=(int)(j);i<=(int)(k);i++)
#define rrep(i,j,k) for(register int i=(int)(j);i>=(int)(k);i--)

ll read(){
    ll x=0,f=1;char c=getchar();
    while(c<'0' || c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0' && c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

const int MAXN = 510;

int mod;
int a[MAXN];
int dp[MAXN][MAXN];

int add(int a, int b)
{
    return (a + b) % mod;
}

int main()
{
    int n, m, b;
    cin >> n >> m >> b >> mod;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    dp[0][0] = 1;
    for (int i = 0; i < n; i++)
        for (int j = 1; j <= m; j++)
            for (int k = a[i]; k <= b; k++)
                dp[j][k] = add(dp[j][k], dp[j - 1][k - a[i]]);
    int ans = 0;
    for (int i = 0; i <= b; i++)x
        ans = add(ans, dp[m][i]);
    cout << ans << endl;
}

Review：

比较容易的一道题

B

题解：

首先可以通过BFS得到dis[i][j]数组，也就是任意两点的最短路

然后分两种情况

1. 只剩下s1到t1，s2到t2的最短路 代价：m-dis[s1][t1]-dis[s2][t2]

2. 剩下的两条路径有交，组成一个‘H’形状

代价：枚举i，j表示那个交集的两端

然后剩下的边数的可能情况就是dis[s1][i]+dis[s2][i]+dis[i][j]+dis[j][t1]+dis[j][t2] 或者 dis[s1][i]+dis[t2][i]+dis[i][j]+dis[j][t1]+dis[j][s2]

取一个最小值 再用m减去就好了

注意判断这样的i，j不满足l1，l2的要求的情况

Code：

#include<stdio.h>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<cmath>
#include<iostream>
#include<queue>
#include<string>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<long long,long long> pll;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define rep(i,j,k)  for(register int i=(int)(j);i<=(int)(k);i++)
#define rrep(i,j,k) for(register int i=(int)(j);i>=(int)(k);i--)

ll read(){
    ll x=0,f=1;char c=getchar();
    while(c<'0' || c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0' && c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

const int maxn=3030;
int n,m;
vector<int> gr[maxn];
int dis[maxn][maxn];
bool vis[maxn];

void bfs(int u){
    queue<int> q;
    while(!q.empty()) q.pop();
    memset(vis,0,sizeof(vis));
    vis[u]=1;q.push(u);
    while(!q.empty()){
        int v=q.front();
        q.pop();
        for(int i=0;i<gr[v].size();i++){
            int nw=gr[v][i];
            if(vis[nw]) continue;
            vis[nw]=1;
            dis[u][nw]=dis[u][v]+1;
            q.push(nw);
        }
    }
}

int main(){
    n=read(),m=read();
    rep(i,1,m){
        int a=read(),b=read();
        gr[a].pb(b),gr[b].pb(a);
    }
    int s1,t1,l1,s2,t2,l2;
    s1=read(),t1=read(),l1=read();
    s2=read(),t2=read(),l2=read();
    
    rep(i,1,n){
        bfs(i);
    }
    
    if(dis[s1][t1]>l1 || dis[s2][t2]>l2){
        puts("-1");
        return 0;
    }
    int ans1=m-dis[s1][t1]-dis[s2][t2];
    int ans2=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j) continue;
            int nw=dis[s1][i]+dis[s2][i]+dis[i][j]+dis[j][t1]+dis[j][t2];
            if(dis[s1][i]+dis[i][j]+dis[j][t1]>l1 || dis[s2][i]+dis[i][j]+dis[j][t2]>l2) nw=1e9;
            int nw2=dis[s1][i]+dis[t2][i]+dis[i][j]+dis[j][t1]+dis[j][s2];
            if(dis[s1][i]+dis[i][j]+dis[j][t1]>l1 || dis[t2][i]+dis[i][j]+dis[j][s2]>l2) nw2=1e9;
            ans2=max(ans2,max(m-nw,m-nw2));
        }
    }
    printf("%d
",max(ans1,ans2));
    return 0;
}

/*
9 9
1 2
2 3
2 4
4 5
5 7
5 6
3 8
8 9
9 6
1 7 4
3 6 3
*/

Review：

我竟然连能够求出dis数组都没看出来

傻傻的以为要floyd或者n遍dijkstra

没注意到边权为1。。。

所以边权为1----BFS

C

题解：

很显然要用状压dp

（毕竟20的数据范围摆在那里）

那么令$dp[mask]$表示将mask对应的字符串变成easy to remember的最小代价

复杂度最多只能为$O(2^n imes n)$ 所以还可以枚举一层

那么怎么做呢

考虑转移：

首先我们不能做到O（1）转移

所以不能枚举每一个属于mask的字符串

那么我们必须做到对于任意一个属于mask的字符串 通过我们的转移都能够得到答案

所以必须得有两种转移

我们令选取的字符串为$s_i$，剩下的状态为$nwmask$

1. 把$s_i$改动一位，并压进去

因为最多20个字符串而有26个字母，所以可以保证改任意一位都可行

那肯定选择最少的代价的那一位去修改

2. 改动其他的字符串的某一位，使得他们和$s_i$的这一位都不同

这个代价是可以预处理的

Code：

#include <bits/stdc++.h>

#define forn(i, n) for(int i = 0; i < int(n); i++)

using namespace std;

const int N = 20;
const int leng = 300;
string s[N];
int cost[N][leng], c[N][leng], sv[N][leng], a[N][leng];
int d[1 << N];

int main() {
  int n, m;
  cin >> n >> m;
  forn(i, n) cin >> s[i];
  forn(i, n) forn(j, m) cin >> a[i][j];
  
  forn(i, n) {
    forn(j, m) {
      int curv = 0;
      forn(k, n) {
        if (s[i][j] == s[k][j]) {
          sv[i][j] |= (1 << k);
          c[i][j] += a[k][j];
          curv = max(curv, a[k][j]);
        }
      }
      c[i][j] -= curv;
    }
  }
  forn(i, 1 << n) d[i] = 1000000000;
  d[0] = 0;
  forn(mask, 1 << n) {
    if (mask == 0) continue;
    int lowbit = -1;
    forn(i, n) {
      if ((mask >> i) & 1) {
        lowbit = i;
        break;
      }
    }
    forn(i, m) {
      d[mask] = min(d[mask], d[mask & (mask ^ sv[lowbit][i])] + c[lowbit][i]);
      d[mask] = min(d[mask], d[mask ^ (1 << lowbit)] + a[lowbit][i]);
    }
  }
  printf("%d
", d[(1 << n) - 1]);
  return 0;
}

Review：

我觉得挺难的，但是怎么那么多人随手切啊

D

题解：

首先如果只要算1为根的答案是个很简单的树形dp

用$dp[i]$表示以i为根的子树的答案

$dp[i]=prod {(dp[son]+1)}$

然后我们考虑怎么算每个点的答案

我们通过父亲的答案求儿子的答案

怎么做呢？

首先我们看从父亲到儿子有哪些变化

我们用ans[i]记录i结点对应的上方给i的贡献 然后再乘上dp[i]（i的下方对i的贡献）就是i为根的答案

我们怎么计算ans数组呢

发现从父亲到儿子的变化就在于多了几个儿子对应的兄弟

$ans[son]=ans[father] imes prod {(dp[brother]+1)}$

所以我们记录L，R表示当前结点的儿子们的前缀(dp+1)的积，后缀(dp+1)的积

然后$ans[son]=ans[father]*L[son]*R[son]*ans[father]+1$就可以了

+1指的是把儿子的父亲当作儿子的儿子的时候计算答案的时候要把dp+1相乘

Code：

#include<stdio.h>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<cmath>
#include<iostream>
#include<queue>
#include<string>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<long long,long long> pll;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define rep(i,j,k)  for(register int i=(int)(j);i<=(int)(k);i++)
#define rrep(i,j,k) for(register int i=(int)(j);i>=(int)(k);i--)

ll read(){
    ll x=0,f=1;char c=getchar();
    while(c<'0' || c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0' && c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

const int mod=1000000007;
int n;
vector<int> adj[200200];
ll dp[200200],L[200200],R[200200];
ll ans[200200];

void dfs(int x){
    dp[x]=1;
    for(int i=0;i<adj[x].size();i++){
        int v=adj[x][i];
        dfs(v);
        dp[x]=dp[x]*(dp[v]+1)%mod;
    }
}

void dfs2(int x){
    int num=adj[x].size();
    if(num==0) return;
    L[0]=1,R[num-1]=ans[x];
    for(int i=0;i<adj[x].size();i++){
        int v=adj[x][i];
        L[i+1]=L[i]*(dp[v]+1)%mod;
    }
    for(int i=num-1;i>=0;i--){
        int v=adj[x][i];
        R[i-1]=R[i]*(dp[v]+1)%mod;
    }
    for(int i=0;i<num;i++){
        int v=adj[x][i];
        ans[v]=(L[i]*R[i]+1)%mod;
    }
    for(int i=0;i<num;i++){
        int v=adj[x][i];
        dfs2(v);
    }
}

int main(){
    n=read();
    rep(i,2,n){
        int x=read();
        adj[x].pb(i);
    }
    dfs(1);
    ans[1]=1;
    dfs2(1);
    rep(i,1,n)
        printf("%lld ",dp[i]*ans[i]%mod);
    puts("");
    return 0;
}

/*
5
1 2 3 4
*/

Review：

第一个dp很好想

但是怎么求ans不知道怎么想的

可能需要灵机一动？