codeforces 295(Round #179)题解

2A:水题，显然每个数字可以调整到任意位置，于是计算每个数字出现个数，如果大于(n+1)/2则不可以，
其余的必定成立
2B:不错的题。反面考虑比较好，用总数减去所有成立的，即是不成立的方案数
1A:水题，可以写线段树，最好的方法显然是差分数组，先差分操作数，再差分值，最后计算即可

1B:个人认为是一道非常好的题，考察了一个非常重要，但是特别容易忽视的性质。题意是求每次删点前任意两点间的最短路的和。从后往前考虑，相当于每次新加入一个点求最短路，想到了什么？对了，floyd性质,那三层for循环中最外层循环用来更新最短路的意义就是这样，表示新加入这个点来更新最短路。由此，算法出来了，倒着加点求任意两点间最短路即可

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=505;
int d[N][N];
int a[N];
long long f[N];
int main()
{
      int i,j,k,n;
      scanf("%d",&n);
      for(i=1;i<=n;++i)
       for(j=1;j<=n;++j)
        scanf("%d",&d[i][j]);
      for(i=1;i<=n;++i) scanf("%d",&a[i]);
      for(k=n;k>=1;k--)
	{
		for(i=1;i<=n;i++)
		 for(j=1;j<=n;j++)
		   d[a[i]][a[j]]=min(d[a[i]][a[k]]+d[a[k]][a[j]],d[a[i]][a[j]]);
		long long ans=0ll;
		for(i=n;i>=k;i--)
		 for(j=n;j>=k;j--)
		  ans+=d[a[i]][a[j]];
		f[k]=ans;
	}
	for(int i=1;i<=n;i++)    
       printf("%I64d ",f[i]);
      return 0;
}

1C:DP,f[i][j][k]的i表示当前该过河还是该返回，Dp即可，具体细节代码中有注释

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N=55;
const int M=1000000007;
long long c[N][N],f[N][N][2],d[N][N][2];
struct data 
{
  int x;
  int y;
  int z;
};
int main()
{
      int i,j,n,k;
      scanf("%d%d",&n,&k);
      for(i=0;i<=n;++i) c[i][0]=1;
      for(i=1;i<=n;++i)
       for(j=1;j<=i;++j)
        c[i][j]=(c[i-1][j-1]+c[i-1][j])%M;
      int a,b;a=b=0;
      for(i=1;i<=n;++i)
      {
         int t;
         scanf("%d",&t);
         if(t==50) a++;
         else b++;
      }  
      queue<data> q;
      f[0][0][1]=0;
      d[0][0][1]=1;
      int x,y,z,nx,ny,nz;
      q.push((data){0,0,1});
      while(q.size())
      {
         x=q.front().x;y=q.front().y;z=q.front().z;q.pop();
         long long step=f[x][y][z];long long tmp=d[x][y][z];
         if(z==1)  {x=a-x;y=b-y;}//该过河 
         for(i=0;i<=x;++i)
          for(j=(i==0);j<=y;++j) 
           if(i*50+j*100<=k)
           {
              if(z==1) {nx=a-x+i;ny=b-y+j;}//此时要过河，lx为已用的50的个数 
              else {nx=x-i;ny=y-j;}//返回去i个
              nz=1-z;
              if(!f[nx][ny][nz])//未计算过 
              {
                 f[nx][ny][nz]=step+1;
                 q.push((data){nx,ny,nz});
              }  
              if(f[nx][ny][nz]==step+1) 
              d[nx][ny][nz]=(d[nx][ny][nz]+tmp*c[x][i]%M*c[y][j]%M)%M; 
           }
      }
      if(!f[a][b][0]) printf("-1\n0\n");
      else printf("%I64d\n%I64d\n",f[a][b][0],d[a][b][0]);
      return 0;
}

1D:很好的DP，和之前CF那道DP类似，不过更简单一些。f[i][j]表示前i行第i行j个的方案数 g[i][j]表示前i行第i行小于等于j个的方案数。g[i][j] = sigma(f[i][k]*(j-k+1))，枚举g[i][j]显然超时。

我们可以观察以下例子：

g[i][3] = f[i][1] * 3 + f[i][2] * 2 + f[i][3]
g[i][4] = f[i][1] * 4 + f[i][2] * 3 + f[i][3] * 2 + f[i][4]
g[i][4] = g[i][3] + f[i][1] + f[i][2] + f[i][3] + f[i][4];

g[i][j]可以递推来求，然后枚举最长行DP即可

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=2005,MD=1000000007;
int f[N][N],g[N][N];
void add(int &x,int y)
{
      x+=y;
      if(x>=MD) x-=MD;
}
int main()
{
      int i,j,n,m;
      scanf("%d%d",&n,&m);
      for(i=1;i<=n;++i) 
      {
         int sum=0;
         for(j=2;j<=m;++j) 
         {
            add(f[i][j],g[i-1][j]+1);//上一行为空 
            add(sum,f[i][j]);
            add(g[i][j],g[i][j-1]+sum);
         }
      }
      long long ans=0ll;
      for(i=1;i<=n;++i)
      {
        for(j=2;j<=m;++j)
         ans+=(long long)f[i][j]*(g[n-i][j]-f[n-i][j]+1)%MD*(m-j+1)%MD;
        ans=ans%MD;
        //枚举最长行  
      } 
      printf("%I64d",ans); 
      return 0;
}