Codeforces Round #131 (Div. 1) (又是各种dp)

http://codeforces.com/contest/213

A. Game

水题，拓扑排序贪心恶搞

B.
Numbers

给你一个n，要你用一些数字组成一些数，数的长度不大于n，给你0~9的cnt(i)表示组成的数种的i至少要cnt(i)个，组成的数没有前导0。

思路：首先考虑组成的数中没有0的情况，那么相当于是问1~9能组成多少个长度不大于n的数，只不过加了cnt的限制条件。这种做法是很经典的做法，相当于有x种颜色的球，每个球给出数量，问有多少种不同的排列方式。

设组成的数中i的个数为sum(i)个，总数为tot，那么很显然不同排列方式有tot!
/ (sigma(sum(i)!))。

对于这题有个不同的地方就是不能有前导0，如果照普通方法计算的话很多情况是不合法的，刚开始我是枚举总共放多少0的，不过这样子复杂度过不去，然后想了个有点巧妙的方法，先算出所有情况包括有前导0的，然后假设我放了一个0在最前面了，也就是说计算的长度都减1！比如我本来要算长度为n的，现在就是算长度为n-1的了，具体有些小细节的，这题坑的地方是居然没有把单独的0当做合法情况！

// Author : JayYe  Created Time: 2013-11-9 20:29:54
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
typedef __int64 ll;

const int maxn = 100 + 10;
const int mod = 1000000007;

ll fac[maxn], dp[12][maxn], ff[maxn];
int cnt[maxn];

ll exgcd(ll a, ll b, ll &x, ll &y) {
if(!b) {
x = 1; y = 0;
return a;
}
ll ret = exgcd(b, a%b, y, x);
y -= a/b*x;
return ret;
}

ll inv(ll a, ll mod) {
ll x, y, d = exgcd(a, mod, x, y);
if(x < 0)   x += mod;
return x;
}

void init(int n) {
fac[0] = ff[0] = 1;
for(int i = 1;i <= n; i++)  fac[i] = fac[i-1]*i%mod;
for(int i = 1;i <= n; i++)
ff[i] = inv(fac[i], mod);
}

ll cal(int n, int tot) {
for(int i = 0;i < 10; i++)
for(int j = 0;j <= n; j++)
dp[i][j] = 0;
for(int i = cnt[0];i <= n; i++) dp[0][i] = ff[i];
for(int i = 1;i < 10; i++) {
for(int j = cnt[i];j <= n; j++) {
for(int k = 0;k <= n-j; k++) if(dp[i-1][k]) {
dp[i][j+k] = (dp[i][j+k] + dp[i-1][k]*ff[j]%mod)%mod;
}
}
}
ll ret = 0;
for(int i = 1;i <= n; i++) {
ret = ret + dp[9][i]*fac[i]%mod;
ret %= mod;
}
return ret%mod;
}

int main() {
init(100);
int n;
scanf("%d", &n);
int tot = 0;
for(int i = 0;i < 10; i++) {
scanf("%d", &cnt[i]);
tot += cnt[i];
}
if(tot > n) return puts("0"), 0;

ll ans = cal(n, tot);
if(!tot)    ans--;
if(cnt[0]) {
cnt[0]--;
ans -= cal(n-1, tot-1);
}
else {
ans -= cal(n-1, tot);
}
printf("%I64d\n", (ans%mod + mod)%mod);
return 0;
}

C. Relay Race

很不错的dp！

给你一个矩阵，问你一只乌龟从左上角走两遍到右下角，(x,
y)只可以走到(x+1,y),(x,y+1)，中间经过的所有点的值的总和最大为多少，重复走的只计算一次。

思路：现在考虑成两只不同乌龟一起同步走的状态，设dp[i][j][k]表示左边的乌龟在第i行第j列并且右边的乌龟在j+k列，由于是同步走的，所以可以计算出右边乌龟具体的位置，然后状态转移只有四种，很容易写了接下来~具体见代码~

// Author : JayYe  Created Time: 2013-11-10 11:00:46
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

const int maxn = 300 + 5;
const int INF = 1<<30;

int a[maxn][maxn], dp[maxn][maxn][maxn];

int fix(int x1, int y1, int x2, int y2) {
if(x1 == x2 && y1 == y2)    return a[x1][y1];
return a[x1][y1] + a[x2][y2];
}

int main() {
int n;
scanf("%d", &n);
for(int i = 1;i <= n; i++)
for(int j = 1;j <= n; j++)
scanf("%d", &a[i][j]);
for(int i = 1;i <= n; i++)
for(int j = 1;j <= n; j++)
for(int k = 0;k <= n; k++)
dp[i][j][k] = -INF;
dp[1][1][0] = a[1][1];
for(int i = 1;i <= n; i++) {
for(int j = 1;j <= n; j++) {
for(int k = 0;k <= n; k++) if(dp[i][j][k] > -INF){
int x1 = i, y1 = j, y2 = y1 + k, x2 = i + j - y2;
dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k] + fix(i, y1+1, x2, y2+1));
if(k > 0)
dp[i][j+1][k-1] = max(dp[i][j+1][k-1], dp[i][j][k] + fix(i, y1+1, x2+1, y2));
dp[i+1][j][k] = max(dp[i+1][j][k], dp[i][j][k] + fix(i+1, j, x2+1, y2));
dp[i+1][j][k+1] = max(dp[i+1][j][k+1], dp[i][j][k] + a[i+1][j] + a[x2][y2+1]);
}
}
}
printf("%d\n", dp

[0]);
return 0;
}