2018.4.7

4月份的学考选考开始了。想起6月份自己也要经历这样的折磨，心里还是有点慌得——我这次学考能拿A吗？？？拿几个？？？或者说还有没过的？？？
要相信自己。

今天打了ACM式的一整天比赛。。
8道DP题，从早到晚。真是刺激。

只过了4道。

DP根本不熟练。。
理解还不到位。。树形DP要在学习一下。

T1

题面

为了使问题简化，假设在接下来的一段时间里，馅饼都掉落在0-10这11个位置。开始时小王站在5这个位置上，因此在第一秒，他只能接到4,5,6这三个位置中其中一个位置上的馅饼。问小王最多可能接到多少个馅饼？（假设他的背包可以容纳无穷多个馅饼）
Input
输入数据有多组。每组数据的第一行为以正整数n，表示有n个馅饼掉在这条小径上。在结下来的n行中，每行有两个整数x,T,表示在第T秒有一个馅饼掉在x点上。同一秒钟在同一点上可能掉下多个馅饼。n= 0时输入结束。
Output
每一组输入数据对应一行输出。输出一个整数m，表示小王最多可能接到m个馅饼。

Sample Input
6
5 1
4 1
6 1
7 2
7 2
8 3
0
Sample Output
4

解析

加强版数字三角形。
f[i][j]=max(dp[i-1][j+1],dp[i-1][j],dp[i-1][j-1]）+sum[i][j];(i是时间，j是位置)
其中有些小坑，比如在5s之前，有些地点是不能到达的，要处理一下。

实现

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int num=0,flag=1;
    char c=getchar();
    for(;c<'0'||c>'9';c=getchar())
      if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())
      num=(num<<1)+(num<<3)+c-48;
    return num*flag;
}
int n;
long long dp[20][100010]={};//这里我顺序反了。 
void init()
{
    long long xx,tt;
    while (n=read())
      {
        memset(dp,0,sizeof(dp));
        long long maxt=0,mint=10000010,maxx=0;
        for(int i=1;i<=n;++i)
          {
            xx=read();
            tt=read();
            dp[xx][tt]++;
            mint=min(mint,tt);
            maxt=max(maxt,tt);
          }
        int l=0,r=10;
        for(int i=mint;i<=maxt;++i)
          {
            if (i<=5) l=5-i,r=5+i;
            else l=0,r=10;
            dp[l][i]+=max(dp[l][i-1],dp[l+1][i-1]);
            dp[r][i]+=max(dp[r][i-1],dp[r-1][i-1]);
            for(int j=l+1;j<=r-1;++j)
              dp[j][i]+=max(max(dp[j-1][i-1],dp[j][i-1]),dp[j+1][i-1]);
          }
        if (maxt<=5) l=5-maxt,r=5+maxt;
        else l=0,r=10;
        for(int i=l;i<=r;++i)
          maxx=max(maxx,dp[i][maxt]);
        printf("%lld\n",maxx);
      }
}
int main()
{
    init();
    return 0;
}

T2

题面

话说某个幸运的小伙伴X拿到了kevin女神送的蛋糕，然而他的吃法非常奇特，他独创了两种吃蛋糕的办法：一、一次吃一整个蛋糕；二、一次吃k个蛋糕。
那么，当蛋糕数量为x1到x2之间时，一共能有几种不同的吃法呢？
由于答案很大，输出结果mod 1000000007的值
Input
第一行有两个正整数t,k(1<=t,k<=100000) ，其中t表示数据的组数。
接下来t行，每行两个数x1, x2(1<=x1<=x2<=100000)。
Output
共t行，每行一个正整数x，表示蛋糕数量在x1-x2之间时，一共能有几种不同的吃法，结果对(10^9+7)取模

Sample Input
3 2
1 3
2 3
4 4
Sample Output
6

5

5

解析

递推
对于每一个i可以有两种选择，就是吃1个，或者吃k个。
所以可推出dp方程
dp[i]=dp[i-1]+dp[i-k];
应该是简单的。
不要忘了减法取模要加上模数再取余。

实现

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int num=0,flag=1;
    char c=getchar();
    for(;c<'0'||c>'9';c=getchar())
      if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())
      num=(num<<1)+(num<<3)+c-48;
    return num*flag;
}
long long dp[100010]={},sum[100010]={};
int t,k,maxt=0,x2[100010]={},x1[100010]={};
void make_()
{
    dp[0]=1;
    for(int i=1;i<=maxt;++i)
      {
        dp[i]+=dp[i-1];
        if (i-k>=0) dp[i]=(dp[i]+dp[i-k])%1000000007;
        sum[i]=(sum[i-1]+dp[i])%1000000007;
      }
}
void init_work()
{
    t=read();
    k=read();
    for(int i=1;i<=t;++i)
      {
        x1[i]=read();
        x2[i]=read();
        maxt=max(x2[i],maxt);
      }
    make_();
    for(int i=1;i<=t;++i)
      printf("%d\n",(sum[x2[i]]-sum[x1[i]-1]+1000000007)%1000000007);
}
int main()
{
    init_work();
    return 0;
}

T3

题面

有n个水果, 每个水果都有两个属性值ai表示美味程度, bi表示能量值, 现在要求选出一个或多个水果, 使得选出的水果的ai和与bi和的比例是k 问在这种清形可能出现的情况下ai的和最多是多少, 如果这样的情形不存在输出 -1
Input
第一行包含两个整数n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). 第二行为 n个整数 a1, a2, …, an (1 ≤ ai ≤ 100) — 水果的美味值. 第三行包含 n integers b1, b2, …, bn (1 ≤ bi ≤ 100) —水果的能量值. Fruit number i has taste ai and calories bi.

Output
如果无解输出-1.

否则输出满足条件的ai累加和

Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1

解析

一开始我用的是二维01背包。
这种算法轻轻松松的就TLE了。
而其实可以将背包问题中的w[i]=a[i]-k*b[i];
然后就01背包。。
要注意一个偏移量。
而且一开始，数组最好设成不合法状态，再将0的偏移位置设为合法。

题解

1.不使用滚动数组。
这样的话不用考虑w[i]的正负问题了。
但复杂度会略高

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int num=0,flag=1;
    char c=getchar();
    for(;c<'0'||c>'9';c=getchar())
      if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())
      num=(num<<1)+(num<<3)+c-48;
    return num*flag;
}
int n,k;
int a[110]={},b[110]={},c[110]={};
int dp[110][50020]={};
void init()
{
    n=read();
    k=read();
    for(int i=1;i<=n;++i)
      a[i]=read();
    for(int i=1;i<=n;++i)
      b[i]=read();
    for(int i=1;i<=n;++i)
      c[i]=a[i]-k*b[i];
}
void dpdp()
{
    memset(dp,-10,sizeof(dp));
    dp[0][10010]=0;
    for(int i=1;i<=n;++i)
      for(int j=10010*2;j>=max(c[i],0);--j)
        dp[i][j]=max(dp[i-1][j],dp[i-1][j-c[i]]+a[i]);
    if (dp[n][10010]>0)printf("%d",dp[n][10010]);
    else cout<<-1;
}
int main()
{
    init();
    dpdp();
    return 0;
}

2.滚动数组，那么对于w[i]就需要进行判断了。
分类处理

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int num=0,flag=1;
    char c=getchar();
    for(;c<'0'||c>'9';c=getchar())
      if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())
      num=(num<<1)+(num<<3)+c-48;
    return num*flag;
}
int n,k;
int a[110]={},b[110]={},c[110]={};
int dp[50020]={};
void init()
{
    n=read();
    k=read();
    for(int i=1;i<=n;++i)
      a[i]=read();
    for(int i=1;i<=n;++i)
      b[i]=read();
    for(int i=1;i<=n;++i)
      c[i]=a[i]-k*b[i];
}
void dpdp()
{
    memset(dp,-10,sizeof(dp));
    dp[10010]=0;
    for(int i=1;i<=n;++i)
      {
        if (c[i]>0)
          for(int j=0;j<=20020;++j)
            dp[j]=max(dp[j],dp[j+c[i]]+a[i]);
        else 
          for(int j=20020;j>=-c[i];--j)
            dp[j]=max(dp[j],dp[j+c[i]]+a[i]);
      } 
    if (dp[10010]<=0) cout<<-1;
    else cout<<dp[10010];
}
int main()
{
    init();
    dpdp();
    return 0;
}

T4

题面

你现在可以给这个匹配的括号序列中的括号染色，且有三个要求:

每个括号只有三种情况，不上色，上红色，上蓝色.
每对括号必须只能给其中的一个上色，且必须给一个上色；For any pair of matching brackets exactly one of them is colored. In other words, for any bracket the following is true: either it or the matching bracket that corresponds to it is colored.
相邻的两个不能上同色，可以都不上色；No two neighboring colored brackets have the same color.
求满足条件的括号序列染色的方法数, 这个数值会比较大，只需要 mod 1000000007 (109 + 7).
Examples
Input
(())
Output
12
Input
(()())
Output
40
Input
()
Output
4

解析

区间DP。
要考虑的东西有很多。
用四维数组，分别表示左边，右边，左颜色，右颜色。
根据题意，分情况处理
我用了一种鬼畜的方法。
每次寻找单独的括号，同一层次的括号合并起来，再向另一层次扩展。
最终可以得到答案。

题解

#include<bits/stdc++.h>
using namespace std;
char s[1000];
const long long mod=1e9+7;
int len;
long long dp[1000][1000][3][3]={};
void add(int l,int r,int mid)
{
     for(int i=0;i<3;++i)
       for(int j=0;j<3;++j)
         for(int x=0;x<3;++x)
           for(int y=0;y<3;++y)
             if (!(x==1&&y==1||x==2&&y==2))
               dp[l][r][i][j]=(dp[l][r][i][j]+dp[l][mid][i][x]*dp[mid+1][r][y][j])%mod;
}
int make_(int l)
{
    int i=l+1;
    for(;i<=len;)
      if (s[i]=='(')
        {
          int en1=i-1;
          i=make_(i);
          add(l+1,i-1,en1);
        }
      else 
        {
          if (l+1==i)
            dp[l][i][0][1]=dp[l][i][0][2]=dp[l][i][1][0]=dp[l][i][2][0]=1;
          else
            {
                dp[l][i][0][1]=(dp[l][i][0][1]+dp[l+1][i-1][0][0]+dp[l+1][i-1][0][2]+dp[l+1][i-1][1][0]+dp[l+1][i-1][1][2]+dp[l+1][i-1][2][0]+dp[l+1][i-1][2][2])%mod;
                dp[l][i][0][2]=(dp[l][i][0][2]+dp[l+1][i-1][0][0]+dp[l+1][i-1][0][1]+dp[l+1][i-1][1][0]+dp[l+1][i-1][1][1]+dp[l+1][i-1][2][0]+dp[l+1][i-1][2][1])%mod;
                dp[l][i][1][0]=(dp[l][i][1][0]+dp[l+1][i-1][0][0]+dp[l+1][i-1][0][1]+dp[l+1][i-1][0][2]+dp[l+1][i-1][2][0]+dp[l+1][i-1][2][1]+dp[l+1][i-1][2][2])%mod;
                dp[l][i][2][0]=(dp[l][i][2][0]+dp[l+1][i-1][0][0]+dp[l+1][i-1][0][1]+dp[l+1][i-1][0][2]+dp[l+1][i-1][1][0]+dp[l+1][i-1][1][1]+dp[l+1][i-1][1][2])%mod;
            }
          return i+1;
        }
}
int main()
{
    scanf("%s",s+1);
    len=strlen(s+1);
    int i=1;
    for(;i<=len;)
      {
        int en1=i-1;
        i=make_(i);
        if (en1)
          add(1,i-1,en1);
      }
    printf("%lld",(dp[1][len][0][0]+dp[1][len][0][1]+dp[1][len][0][2]+dp[1][len][1][0]+dp[1][len][1][1]+dp[1][len][1][2]+dp[1][len][2][0]+dp[1][len][2][1]+dp[1][len][2][2])%mod); 
    return 0;
} 

T5

题面

现有一个字符串 s = s1s2… s|s| of length |s|, 由小写字符组成. 现在有 q 次查询, 每次查询给两个整数 li, ri (1 ≤ li ≤ ri ≤ |s|). 每次查询你的程序要给出此字符串的子串 s[li… ri]有多少个回文串.

String s[l… r] = slsl + 1… sr (1 ≤ l ≤ r ≤ |s|) is a substring of string s = s1s2… s|s|.

字符串 t 叫 回文串的条件是, 如果这个字符串从左往右读与从右往左读是一样的. Formally, if t = t1t2… t|t| = t|t|t|t| - 1… t1.
Input
caaaba
5
1 1
1 4
2 3
4 6
4 5
Output
1
7
3
4
2

解析

区间DP
通过区间扩展和容斥原理。
dp方程如下
dp[st][en]=dp[st+1][en]+dp[st][en-1]-dp[st+1][en-1];
if (s[st]==s[en]&&f[st+1][en-1]) dp[st][en]++,f[st][en]=1;

题解

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int num=0,flag=1;
    char c=getchar();
    for(;c<'0'||c>'9';c=getchar())
      if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())
      num=(num<<1)+(num<<3)+c-48;
    return num*flag;
}
int dp[5010][5010]={};
char s[5010];
bool f[5010][5010]={};
int l,n;
void make_()
{
    for(int i=1;i<=l;++i)
      dp[i][i]=1,f[i][i]=1,f[i+1][i]=1;
    for(int i=2;i<=l;++i)
      for(int st=1;st<=l-i+1;++st)
        {
            int en=st+i-1;
            dp[st][en]=dp[st+1][en]+dp[st][en-1]-dp[st+1][en-1];
            if (s[st]==s[en]&&f[st+1][en-1]) dp[st][en]++,f[st][en]=1;
        }
}
void init_work()
{
    scanf("%s",s+1);
    l=strlen(s+1);
    make_();
    n=read();
    int x1,x2;
    for(int i=1;i<=n;++i)
      {
        x1=read();
        x2=read();
        printf("%d\n",dp[x1][x2]);
      }
}
int main()
{
    init_work();
    return 0;
}

T6

题面

给你一个长度为n的长字符串，“完美子串”既是它的前缀也是它的后缀，求“完美子串”的个数且统计这些子串的在长字符串中出现的次数

Input
在一行中有长字符串s1s2…s|s| (1 ≤ |s| ≤ 105) — string s. 且字符串只包含大写字符。

Output
在第一行中, 输出整数 k (0 ≤ k ≤ |s|) — 表示“完美子串”的个数 s. 然后输出k 行,在每一行中输出两个整数li ci. li ci 分别表示前li个字符为“完美子串” 和 该完美子串在原串中出现的次数, 以 li递增为序输出 li ci.

Example
Input
ABACABA
Output
3
1 4
3 2
7 1
Input
AAA
Output
3
1 3
2 2
3 1

解析

KMP的next数组的又一灵活操作。
从lens开始跳next，不断往前跳跃。
然后记录跳到的前缀的出现次数。
就是答案。

题解

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int num=0,flag=1;
    char c=getchar();
    for(;c<'0'||c>'9';c=getchar())
      if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())
      num=(num<<1)+(num<<3)+c-48;
    return num*flag;
}
char s[100010];
int next[100010]={},sum[100010]={},a[100010]={};
bool f[100010]={};
int len;
void KMP()
{
    int j=0,cnt=0;
    for(int i=2;i<=len;++i)
      {
        while (j>0&&s[i]!=s[j+1]) j=next[j];
        if(s[i]==s[j+1]) ++j;
        next[i]=j;
      }
    j=next[len];
    while (j>0)  f[j]=1,a[++cnt]=j,j=next[j];
    printf("%d\n",cnt+1);
    for(int i=len;i>=1;--i)  
      {
        sum[i]++;
        sum[next[i]]+=sum[i];
      }
    for(int i=cnt;i>=1;--i)
      printf("%d %d\n",a[i],sum[a[i]]);
    printf("%d %d",len,1);
}
int main()
{
    scanf("%s",s+1);
    len=strlen(s+1);
    KMP();
    return 0;
}

T7

题面

树是一个无环联通图. 现在给你一个 n 个点的树. 树的 重心 的定义为，如果把这个点去掉，剩余的每个联通分量的结点个数不会超过.

给定 n个点的树，现在你可以进行一次移边操作. 移边 指的是删除一条边 (不删除相应的点) 再增加一条边 (不增加新的点) 操作后还这个图还具有树的性质. 现在问，如果可以进行一次移边操作，每个点是否可以成为树的重心。
Input
第一行包含一个整数 n (2 ≤ n ≤ 400 000) — 表示树的结点数. 接下来 n - 1 包含两个整数 ui 和 vi (1 ≤ ui, vi ≤ n) —一个边连接的两个点的编号.

Output
Print n integers. The i-th of them should be equal to 1 if the i-th vertex can be made centroid by replacing no more than one edge, and should be equal to 0 otherwise.

Examples
Input
3
1 2
2 3
Output
1 1 1
Input
5
1 2
1 3
1 4
1 5
Output
1 0 0 0 0

解析

暂不会

T8

题面

给定n个城市，他们之间的连接方式为一棵树 ，由n-1条道路直接连接，这n-1条道路的长度都是相同的

现在有 2k 个不同的城市想与其他城市建立友好城市.

现在你的问题是，如何让这些城市完成匹配，或者叫友好城市配对后，这些友好城市之间的距离累加和最大。

Input
第一行包含两个整数： n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ n / 2) — 表示城市的个数与友好城市的对数. 城市的编号是从 1 到 n.

第二行包含 2k 不同的整数u1, u2, …, u2k (1 ≤ ui ≤ n) — 友好城市的编号.

接下来 n - 1 行表示对应的道路. 每行包含两个整数 xj and yj (1 ≤ xj, yj ≤ n), 这个表示 j-th 道路连接 xj 和 yj. 这些道路是双向的.

Output
Print the maximum possible sum of distances in the division of universities into k pairs.

Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9

解析

树型DP
从根节点往下搜，返回过程中记录每个节点各子树的节点个数。
当大于未处理友好城市总数的一半时，说明子树内部需要进行匹配。匹配到小于剩余友好城市总个数一半。
为什么这样？
对于一个节点的各个子树，如果把他们全部友好城市和其他节点子树的友好城市匹配，他们到达此节点的路径总和是一定的。且一定比内部匹配要优。
所以尽量多得将友好城市向其他子树匹配。

题解

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int num=0;
    char c=getchar();
    for(;c<'0'||c>'9';c=getchar());
    for(;c<='9'&&c>='0';c=getchar())
      num=(num<<1)+(num<<3)+c-48;
    return num; 
}
int n,k,t=0,now;
long long ans=0;
int sum[200010]={};
bool v[200010]={},vis[200010]={};
struct node
{
    int y,next;
}a[400010];
int linkk[200010]={};
void insert(int xx,int yy)
{
    a[++t].y=yy;
    a[t].next=linkk[xx];
    linkk[xx]=t;
}
void init()
{
    int y,x;
    n=read();now=read();
    now*=2;
    for(int i=1;i<=now;++i)
      {
        x=read();
        v[x]=1;
      }
    for(int i=1;i<n;++i)
      {
        x=read();y=read();
        insert(x,y);
        insert(y,x);
      }
}
void dfs(int root)
{
    vis[root]=1;
    for(int i=linkk[root];i;i=a[i].next)
      if (!vis[a[i].y])
        {
            dfs(a[i].y);
            sum[root]+=sum[a[i].y]; 
        }
        ans+=sum[root];
        if (v[root]) 
          ++sum[root];
    while (sum[root]>now/2)
      {
        int temp=(sum[root]+1-now/2)/2*2;
        sum[root]-=temp;
        now-=temp;
      }
}
int main()
{
    init();
    dfs(1);
    printf("%lld",ans);
    return 0;
}