【集训】2017icpc北京

E Cats and Fish

m(5000)条鱼拿去喂n(100)只猫，给出每只猫吃一条鱼的时间(2000)，当吃完一条后立即喂下一条，鱼不够时优先给吃速快的猫喂，问第x(1000)时刻后还剩下几条完整的鱼，几条不完整的鱼。

使用不易错的方法去写题

签到题，但是我浪费了很多时间。
这道题只有1000个时刻，每个时刻最多有100个事件发生，可以直接模拟时间推移。注意把每个时刻分为左时刻和右时刻，在左时刻计算鱼的情况，右时刻进行发鱼。
因为猫的初始顺序是无关紧要的，所以直接按速度排序即可。

/* LittleFall : Hello! */
#include <bits/stdc++.h>
using namespace std; using ll = long long; inline int read();
const int M = 500016, MOD = 1000000007;

int speed[M];
int now[M];
int main(void)
{
	#ifdef _LITTLEFALL_
	freopen("in.txt","r",stdin);
    #endif

	int m,n,x;
	while(scanf("%d%d%d",&m,&n,&x)!=EOF)
	{
		for(int i=0;i<n;++i)
		{
			now[i] = 0;
			speed[i] = read();
		}
		sort(speed,speed+n);
		int cnt1 = 0, cnt2 = 0; //喂出的数量,吃完的数量
		for(int t=0;t<=x;++t)
		{
			//左时刻
			if(t)
			{
				for(int i=0;i<n;++i)
				{
					if(now[i])
					{
						--now[i];
						if(now[i]==0)
							++cnt2;
					}
				}
			}
			//右时刻
			if(t<x)
			{
				for(int i=0;i<n;++i)
				{
					if(now[i]==0&&cnt1<m)
					{
						now[i]=speed[i];
						++cnt1;
					}
				}
			}
		}
		printf("%d %d\n",m-cnt1,cnt1-cnt2 );
	}
    return 0;
}


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

H Puzzle Game

给n*m(150,150)的数字矩阵(1000)和一个数P(1000)，记矩阵的最大子矩形为M，求把最多一个元素替换为P后的最小M的值.

二维的最大子矩形可以通过枚举上下界与处理前缀和转化成一维的最大子段和问题，复杂度O(n^3)，首先对初始矩阵求一个M。
列举所有可能的情况：
如果把M外的一个元素替换，答案不会比M更优（必定大于等于M的值）。
如果对M内的一个元素替换且变大，那么答案显然变坏，舍弃。
如果对M内的一个元素替换且变小，那么新的最大子矩形的值就是max(不包含P的最大子矩形，M-P0+P)，其中P0是被替换的元素。

如果预处理出不包含每个位置的最大子矩形的值，就可以用O(n^2)枚举替换位置来更新答案。
记excr[r]为不包含第r行的最大子矩形，excc[c]为不包含第c列的最大子矩形，那么不包含位置[r,c]的最大子矩形的值就是max(excr[r],excc[c]).
可以在初始求最大子矩形时顺带处理出excr与excc，前提是行列各枚举一次。

总复杂度$O(2\ast n^3+n^2)=O(n^3)$

查错，检查变量名字！！！！！

/* LittleFall : Hello! */
#include <bits/stdc++.h>
using namespace std; using ll = long long; inline int read();
const int M = 200, MOD = 1000000007;

int save[M][M];
int sumc[M][M], sumr[M][M];
int excc[M], excr[M];
int main(void)
{
	#ifdef _LITTLEFALL_
	freopen("in.txt","r",stdin);
    #endif

	int n,m,p;
	while(scanf("%d%d%d",&n,&m,&p)!=EOF)
	{
		memset(excr,0xc0,sizeof(excr));
		memset(excc,0xc0,sizeof(excc));
		//read in
		for(int i=1;i<=n;++i)
			for(int j=1;j<=m;++j)
				save[i][j] = read();
		//cal sum
		for(int i=1;i<=n;++i)
			for(int j=1;j<=m;++j)
				sumc[i][j] = sumc[i][j-1] + save[i][j],
				sumr[i][j] = sumr[i-1][j] + save[i][j];
		//cal initial ans, excr
		int ans = INT_MIN;
		int ar1,ar2,ac1,ac2; 
		for(int r1=1;r1<=n;++r1)
		{
			for(int r2=r1;r2<=n;++r2)
			{
				int tas, tta, tac1, tac2, ttc1, ttc2;
				tas = tta = sumr[r2][1] - sumr[r1-1][1];
				tac1 = tac2 = ttc1 = ttc2 = 1;
				for(int c=2;c<=m;++c)
				{
					int val = sumr[r2][c] - sumr[r1-1][c];
					if(tta + val > val) tta = tta + val, ttc2 = c;
					else tta = val, ttc1 = ttc2 = c;
					if(tta > tas) tas = tta, tac1 = ttc1, tac2 = ttc2;
				}
				if(tas>ans)
					ans = tas, ar1 = r1, ar2 = r2, ac1 = tac1, ac2 = tac2;
				for(int r=1;r<=n;++r) if(r<r1||r>r2)
					excr[r] = max(excr[r], tas);
			}
		}
		//cal excc
		int cans = INT_MIN;
		for(int c1=1;c1<=m;++c1)
		{
			for(int c2=c1;c2<=m;++c2)
			{
				int tas, tta;
				tas = tta = sumc[1][c2] - sumc[1][c1-1];
				for(int r=2;r<=n;++r)
				{
					int val = sumc[r][c2] - sumc[r][c1-1];
					tta = max(tta+val, val);
					tas = max(tas, tta);
				}
				cans = max(cans, tas);
				for(int c=1;c<=m;++c) if(c<c1||c>c2)
					excc[c] = max(excc[c],tas);
			}
		}
		int res = ans;
		for(int r=ar1;r<=ar2;++r)
		{
			for(int c=ac1;c<=ac2;++c)
			{
				if(p < save[r][c])
				{
					int val = max(max(excr[r],excc[c]),ans-save[r][c]+p);
					res = min(res, val);
				}
			}
		}
		printf("%d\n",res );
	}


    return 0;
}


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

J - Pangu and Stones

n(100)堆石子，每次可以把连续的x(L<=x<=R)堆合并为一堆，花费代价为它们的和，问合并为一堆的最小代价，如果不能合并，输出0.

DP
状态表示：$dp[i][j][k]$表示原第i堆到第j堆合并为k堆的最小花费。
状态边界：$dp[i][j][j-i+1]=0，其它=inf$
状态转移：
当 k 为 1 时 ， d p [ i ] [ j ] [ k ] = m i n x = L R m i n p = i j − 1 { d p [ i ] [ p ] [ x − 1 ] + d p [ p + 1 ] [ j ] [ 1 ] } + s u m [ i ] [ j ] 当k为1时，dp[i][j][k]=min_{x=L}^Rmin_{p=i}^{j-1}\{dp[i][p][x-1]+dp[p+1][j][1]\}+sum[i][j] 当k为1时，dp[i][j][k]=minx=LR​minp=ij−1​{dp[i][p][x−1]+dp[p+1][j][1]}+sum[i][j]，表示把x堆用合并操作合并为一堆。
当 k &gt; 1 时 ， d p [ i ] [ j ] [ k ] = m i n p = i j − 1 { d p [ i ] [ p ] [ k − 1 ] + d p [ p + 1 ] [ j ] [ 1 ] } 当k&gt;1时，dp[i][j][k] = min_{p=i}^{j-1}\{dp[i][p][k-1]+dp[p+1][j][1]\} 当k>1时，dp[i][j][k]=minp=ij−1​{dp[i][p][k−1]+dp[p+1][j][1]}，表示向上更新答案。

/* LittleFall : Hello! */
#include <bits/stdc++.h>
using namespace std; using ll = long long; inline int read();
const int M = 128, MOD = 1000000007;

ll save[M];
ll sum[M][M];
ll dp[M][M][M]; //dp[i][j][k]表示i到j合并为k堆的花费
int main(void)
{
	#ifdef _LITTLEFALL_
	freopen("in.txt","r",stdin);
    #endif

	int n,l,r;
	while(scanf("%d%d%d",&n,&l,&r)!=EOF)
	{
		for(int i=1;i<=n;++i)
			save[i] = read();
		for(int i=1;i<=n;++i)
		{
			sum[i][i] = save[i];
			for(int j=i+1;j<=n;++j)
				sum[i][j] = sum[i][j-1] + save[j];
		}
		memset(dp,0x3f,sizeof(dp));

		for(int i=1;i<=n;++i)
			for(int j=i;j<=n;++j)
				dp[i][j][j-i+1] = 0;
		for(int len=0;len<n;++len)
		{
			for(int i=1;len+i<=n;++i)
			{
				int j = i + len;
				//k=1
				for(int x=l;x<=r;++x)
				{
					for(int p=i;p<j;++p)
					{
						dp[i][j][1] = min(dp[i][j][1], dp[i][p][x-1]+dp[p+1][j][1]+sum[i][j]);
					}
				}
				//k>1
				for(int k=2;k<=len;++k)
				{
					for(int p=i;p<j;++p)
					{
						dp[i][j][k] = min(dp[i][j][k],dp[i][p][k-1]+dp[p+1][j][1]);
					}
				}
			}
		}
		printf("%lld\n",(dp[1][n][1]==dp[0][0][0])?0:dp[1][n][1] );
	}

    return 0;
}


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