昨天在队长的blog上看到了一组DP题的题解，好像是给我们新队员做的，不过我发现我没做过（囧），手痒就敲了。
here
1 . poj - 2817 WordStack
题意 ： 给你一些字符串，让你给它们排个序，然后 在可以前置0的情况下，求能获得的最大配对数量。
思路 ： 先预处理出任意两个字符串之间的最大配对数量，然后状态压缩求最大排列（似乎有人全排列也过了，orz）
用一个dp[i][k]数组记录当状态为i并且最后一个加进去的是k的最优值
#include
#include
#include
using namespace std;
typedef __int64 LL;
#define max(a,b) (a > b ? a : b)
const int INF = 1 << 28;
char ss[11][50];
int N , G[12][12];
int dp[1<<12][12];
int solve(int x,int y)
{
int N1 = strlen(ss[x]);
int N2 = strlen(ss[y]);
int ans = 0, i, j;
for (i = 0;i < N1;i++)
{
int sum = 0;
for (j = 0;j < N2 && i+j < N1;j++)
if (ss[y][j] == ss[x][j+i])sum++;
ans = max(ans,sum);
}
for (i = 0;i < N2;i++)
{
int sum = 0;
for (j = 0;j < N1 && i+j < N2;j++)
if (ss[x][j] == ss[y][i+j])sum++;
ans = max(ans,sum);
}
return ans;
}
void init()
{
int i , j;
for (i = 0;i < N;i++)
{
for (j = 0;j < i;j++)
G[i][j] = G[j][i] = solve(i,j);
G[i][i] = 0;
}
}
void debug()
{
int i , j;
for (i = 0;i < N;i++)
{
for (j = 0;j < N;j++)
printf("%d ",G[i][j]);
printf("\n");
}
}
int main()
{
while (scanf("%d",&N) && N)
{
int i , j , k;
for (i = 0;i < N;i++)
scanf("%s",ss[i]);
init();
//debug();
memset(dp,0,sizeof(dp));
int Max = (1< PS : 这道题目，一开始题目没看清楚，预处理成了最大公共序列了，然后跪了一个上午，，囧。
2.poj - 1745 Divisibility
题意 ：给你n（n<=1W）个数让你补上n-1个‘+’或者'-'问你最终的结果是否有可能被k整除。一开始看到1W个数感觉一点想法都没，后来看到了k 的范围是2 ~ 100，水啊。因为求余后最终结果是只有(-k+1) ~ (k-1) 。所以直接开个（2*k*n）二维数组推过去了（可以用滚动数组优化空间，我懒了，囧），时间复杂度在O（n*k）。
#include
#include
#include
using namespace std;
typedef __int64 LL;
bool dp[10005][205];
int aa[10005];
int main()
{
int N,K,i,j;
scanf("%d%d",&N,&K);
for (i = 1;i <= N;i++)
scanf("%d",&aa[i]);
memset(dp,0,sizeof(dp));
dp[1][aa[1]%K] = 1;
for (i = 2;i <= N;i++)
for (j = -K+1;j < K;j++)if (dp[i-1][j])
{
dp[i][(j+aa[i])%K] = 1;
dp[i][(j-aa[i])%K] = 1;
}
if (dp[N][0])printf("Divisible\n");
else printf("Not divisible\n");
return 0;
} 题意 ： 求最大[] 和 （）匹配数。
思路 ： 枚举任意一段长度为0~ n的区间，然后如果ss[i]和ss[j]是配对的话则dp[i][j] = dp[i+1][j-1] + 2;在合并区间就OK了。
#include
#include
#define max(a,b) (a > b ? a : b)
const int maxn = 105;
char ss[maxn];
int dp[maxn][maxn];
int len;
int main()
{
while (scanf("%s",ss) && ss[0] != 'e')
{
int i,j,k;
len = strlen(ss);
memset(dp,0,sizeof(dp));
for (k = 0;k < len;k++) //枚举所有长度的区间
for (i = 0,j = k;j < len;i++,j++)
{
if ((ss[i] == '(' && ss[j] == ')') || (ss[i] == '[' && ss[j] == ']'))
dp[i][j] = dp[i+1][j-1] + 2; //因为[i+1,j-1]的长度是小于现在的k所以肯定已经算过了的
for (int t = i;t < j;t++)
dp[i][j] = max(dp[i][j],dp[i][t]+dp[t+1][j]);
}
printf("%d\n",dp[0][len-1]);
}
return 0;
} 4 . poj - 2537 Tight words
题意 ： 给你0~k k+1个数字，让你组成一个长度为n的字母（可以前面放0）问你任意相邻的数字相差不超过1的摆放的期望是多少。
思路 ：简单数位DP题，我是用dfs记忆化搜索下去了，不过一开始因为开的是int，数据溢出了(n <= 100)，后来开double ,然后再其它优化了下，就过了、
ps : 话说在敲这道题目中我自己宏定义了一个abs(x) （#define abs(x) (x > 0 ? x : -x)），结果出错了、然后用stdlib.h中的abs过了，后来把宏定义改成函数形式，也过了。。囧，，，为什么宏定义过不了啊。。。
#include
#include
#include
//#define Abs(x) (x > 0 ? x : -x)
#define max(a,b) (a > b ? a : b)
int n,k;
double dp[105][15];
double dfs(int len,int num)
{
int i;
double ans = 0;
if (len == 0)return 1.0;
if (dp[len][num] > 0)return dp[len][num];
for (i = 0;i <= k;i++)
{
if (abs(num-i) > 1)continue;
ans += dfs(len-1,i);
}
dp[len][num] = ans;
return ans;
}
int main()
{
while (scanf("%d%d",&k,&n) != EOF)
{
double ans = 0;
int i,j;
for (i = 0;i <= n;i++)
for (j = 0;j <= k;j++)dp[i][j] = -1;
for (i = 0;i <= k;i++)
{
ans = ans + dfs(n-1,i);
}
ans *= 100.0;
for (i = 1;i <= n;i++)
{
ans = ans / (k+1);
}
printf("%.5f\n",ans);
}
return 0;
} 5 . poj - 3018 Giftbox
题意 : n组数据（可以改变次序），每组d个（可以改变次序），问你最长包含前一项的有多少。（解释的有点伤，反正就是和LCS差不多啦， - - ）
思路 ：两次sort之后求LCS即可了，数据水啊，O(n^2*d)的复杂度竟然也能过（囧）。
#include
#include
#include
using namespace std;
#define max(a,b) (a > b ? a : b)
const int maxn = 1005;
int w[maxn];
int aa[505][maxn];
int dp[maxn],sum[maxn];
int N,M;
bool vis[maxn];
int cmp(const int i,const int j)
{
return sum[i] < sum[j];
}
int isok(int x1,int y1)
{
int x = w[x1];
int y = w[y1];
int i;
for (i = 1;i <= M;i++)
if (aa[x][i] <= aa[y][i])return 0;
return 1;
}
int solve()
{
int i , j , cnt = 0;
for (i = 1;i <= N;i++)
{
int max_n = 0;
bool flag = 0;
for (j = 0;j < i;j++)if (vis[j] && isok(i,j))
{
if (dp[j] > max_n)max_n = dp[j];
flag = 1;
}
vis[i] = flag;
if (flag)
{
dp[i] = max_n + 1;
cnt = max(cnt,dp[i]);
}
else dp[i] = 0;
}
return cnt;
}
int main()
{
while (scanf("%d%d",&N,&M) != EOF)
{
int i , j;
for (i = 0;i <= N;i++)
{
sum[i] = 0;
for (j = 1;j <= M;j++)
scanf("%d",&aa[i][j]),sum[i] += aa[i][j];
sort(aa[i]+1,aa[i]+M+1);
w[i] = i;
}
sort(w+1,w+N+1,cmp);
memset(vis,0,sizeof(vis));
vis[0] = 1;
int ans = solve();
if (ans != 0)printf("%d\n",ans);
else printf("Please look for another gift shop!\n");
}
return 0;
} 6 . POJ-2385 Apple Catching
题意 ： 两棵树之间吃apple，但是有个限制：只能换k次树
思路 ：可以先预处理出在第i次换树后在时间j上是否可以吃到apple，然后O(k*n)优化。
PS ： 以前做过这道题目，那时不会，看了题解之后才会的，这次，用了和上次不同的方法，随手敲了一个竟然过了（话说，后来发现状态转移的时候自己有个地方手贱还写错了。orz....）
#include
#include
#include
const int maxn = 1005;
#define max(a,b) (a > b ? a : b)
int n,k;
bool at[maxn][2];
int dp[maxn][40];
int main()
{
int i , j;
scanf("%d%d",&n,&k);
for (i = 1;i <= n;i++)
{
int a;
scanf("%d",&a);
at[i][0] = (a == 1 ? 1 : 0);
at[i][1] = !at[i][0];
}
memset(dp,0,sizeof(dp));
for (i = 0;i <= k;i++)
{
for (j = 1;j <= n;j++)
dp[j][i] = max(dp[j-1][i]+at[j][i%2],dp[j-1][i-1]+at[j][i%2]);
}
int ans = 0;
for (i = 1;i <= n;i++)
ans = max(ans , dp[i][k]);
printf("%d\n",ans);
return 0;
}
7 . POJ-1976 A Mini Locomotive
题意 ： 给你一段数列，然后让你求3段不想交的使得和最大、
思路 ： 前段时间总结过类似的题目，所以做这道题目的时候感觉没多大的压力，先预处理出一个num[i]表示[i,i+k-1]这一段的和，然后就是O（3*n）进行优化。dp[i][j]表示[1,i]选j段的最优态。
状态转移方程为dp[i][j] = max(dp[i-1][j],dp[i-k][j-1]+num[i-k+1])
#include
#include
#include
using namespace std;
const int maxn = 500005;
#define max(a,b) (a > b ? a : b)
int n,k;
int num[maxn],aa[maxn];
int dp[maxn][4];
void debug()
{
int i;
for (i = 1;i <= n-k+1;i++)printf("%d ",num[i]);
printf("\n");
}
int main()
{
int T;
scanf("%d",&T);
for (int cas = 1;cas <= T;cas++)
{
int i,j;
scanf("%d",&n);
for (i = 1;i <= n;i++)
scanf("%d",&aa[i]);
scanf("%d",&k);
num[1] = 0;
for (i = 1;i <= k;i++)
num[1] += aa[i];
for (i = 2;i <= n-k+1;i++)
{
num[i] = num[i-1] - aa[i-1] + aa[k+i-1];
}
//debug();
memset(dp,0,sizeof(dp));
int ans = 0;
for (i = 1;i <= 3;i++)
{
for (j = k * i;j <= n;j++)
{
dp[j][i] = max(dp[j-1][i],dp[j-k][i-1] + num[j-k+1]);
ans = max(dp[j][i],ans);
}
}
printf("%d\n",ans);
}
return 0;
} 似乎还有几道树形DP题，感觉自己现在还没打算学树形DP题，所以没挂。下次补齐！！
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~