1.减操作(ACWING)
若有 a b c d e f g 几个数，
先对位置d操作 变成 a b c d - e f g
再对c操作 变成 a b c - (d-e) f g
仔细分析后得出结论：对于第一个数如a, 它一定为正数，第二个数b,一定为负数，而其他数一定可以通过一些操作被加或者被减， 将题意转化为了改变某个数（>2)的正负性得到 t
dp[ i ][ j ]表示前i个数的和为 j 的第 i 个数之前的符号
核心DP代码
f[1][a[1] + base] = 1;//防止负下标
f[2][a[1] - a[2] + base] = -1;
for(int i = 3; i <= n; i ++)
{
for(int j = -10000 + base; j <= 10000 + base; j ++)
{
if(f[i - 1][j] != 0)
{
f[i][j + a[i]] = 1;
f[i][j - a[i]] = -1;
}
}
}另进行操作的位置一定是符号为正的位置
2.旅行（ACWING)
最长公共子序列 + 输出所有方案
用DFS来输出所有方案，加一个剪枝
f [ i ][ j ] 表示 a 串的前 i 个字母 和 b 串的前 j 个字母的最大相同长度
fa[ i ][ j ] 表示 a 串的前 i 个字符中字母 j + 'a' 出现的最后位置
fb[ i ][ j ] 表示 b 串的前 i 个字符中字母 j + 'a' 出现的最后位置
在找方案的时候，递归下标和长度去找，如在找 a 串前 la 个字符中和 b 串前 lb 个字符有 k 个相同的方案的时候，枚举第 k 个相同的为哪个字母，设为字母 c,那么对于a来说， 选择la之前的靠近la的 c 显然最好，b同理，这刚好是处理的 fa 和 fb 数组
核心DFS代码，因为最长公共子序列就是那个模板
void dfs(int x, int y, int k)
{
if (k == 0)
{
ed.pb(string(ans + 1));
return;
}
for (int i = 0; i < 26; ++i)
{
int a = fa[x][i], b = fb[y][i];
if (f[a][b] != k)
continue;
ans[k] = 'a' + i;
dfs(a - 1, b - 1, k - 1);
}
}自己想想不到用DFS，因为感觉复杂度太大，但没想到还挺快
可能那个剪枝优化了很多状态吧
3.花匠（牛客）
f[ i ][ 0 / 1] 表示到以第 i 个位置结尾是上升 / 下降的最大长度
考虑状态如何转移
对于下降的来说，如果当前点小于上一个点， 即 i - 1 到 i 是下降的，那么需要 i - 2 到 i - 1 是上升的， 否则下降的不能选这个点结尾
if(a[i] < a[i - 1])
f[i][1] = f[i - 1][0] + 1;
else
f[i][1] = f[i - 1][1];对于上升 的来说，如果当前点大于上一个点， 即 i - 1 到 i 是上升的，那么需要 i - 2 到 i - 1 是下降的， 否则上升的不能选这个点结尾
if(a[i] > a[i - 1])
f[i][0] = f[i - 1][1] + 1;
else
f[i][0] = f[i - 1][0];4.愤怒（牛客）
f [ i ][ j ] 表示第一个序列的左括号比右括号多 j 个的合法方案
当读到一个符号，可以选择把它放在第一个还是第二个中
如果是左括号，状态dp[ i ] [ 0 ]只能给第二个序列
而dp [ i ][ j ]可以给第二个序列或者自己留下
if(s[i] == '(')
{
top ++;
dp[i][0] = dp[i - 1][0];//把(直接给了第二个序列
for(int j = 1; j <= top; j ++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % 2333;//给了+自己要
}else
{
top --;
for(int j = top; j >= 0; j --)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j + 1]) % 2333;//给了+自己要
}5.psd面试（牛客）
最长回文子序列
dp[ i ][ j ] 表示 i --- j 这段内的最长回文子串
int n = s.length();
for(int i = n - 1; i >= 0; i --)//枚举起点
{
for(int j = 1; j + i < n; j ++)//枚举区间长度
{
if(s[i] == s[j + i])
dp[i][j + i] = dp[i + 1][j + i - 1] + 2;
else
dp[i][j + i] = max(dp[i + 1][j + i], dp[i][j + i - 1]);
}
}6.找硬币
这道题为什么这么抽象啊
用dp[ i ]表示用最大面额为 i 的凑出答案的最小硬币数
初始化：dp[ 1 ] 表示用 1 来凑出每个物品， 那么初始答案就是所有的物品花费累加和
如果用 2 的纸币需要 10 个，那么用面额为 4 的 需要五个，所以可以用大面额的去更新减少小面额需要的
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n, maxn, ans = 10000000, a[55], dp[100010];
int main()
{
memset(dp, 0x3f, sizeof(dp));
dp[1] = 0;
cin >> n;
for(int i = 1; i <= n; i ++)
{
cin >> a[i];
maxn = max(maxn, a[i]);
dp[1] += a[i];//全部1
}
ans = dp[1];//用1购买全部
for(int i = 1; i <= maxn; i ++)//用i来更新其他
{
for(int j = 2; j * i <= maxn; j ++)//枚举i的倍数
{
int chge = 0;//能用多少个大面额换
for(int r = 1; r <= n; r ++)
chge += a[r] / (i * j);
//每个节省j - 1张
//原先需要dp[i]个， 换成i * j的可以少(j - 1) * chge个
dp[i * j] = min(dp[i * j], dp[i] - (j - 1) * chge);
ans = min(ans, dp[i * j]);
}
}
printf("%d\n", ans);
}7.月之谜（acwing）
感觉数位DP实在克我，对大佬代码进行注释
AcWing 311. 月之谜 - AcWing
/*一个数的余数等于这个数的拆分的余数之和取余*/
/*如 5632 % p = (5000 % p + 600 % p + 30 % p + 2 % p) % p*/
/*所以在下面枚举的时候， 可以记录当前i位对p取余的余数，这样不影响正确性*/
#include <iostream>
#include<cstring>
#define int long long
using namespace std;
const int maxn = 100;
int f[30][maxn][maxn], num[maxn], p;
//f[i][j][k]表示前i个数，当前数位和为sum，且当前余数是k的方案数
int dfs(int u, int sum, int mod, bool limit)//pos为当前数位，sum为当前数位之和(p为枚举的数位之和)，mod为当前余数，limit为上一位是否达到上限的标志
{
if(!u)//已经到了最后一位
{
if(sum == p && !mod) return 1;//如果枚举到了一个存在的数，且是月之数
return 0;
}
if(!limit && f[u][sum][mod] != -1) //当前数不超限且之前被计算过
return f[u][sum][mod];
int res = 0, up = limit ? num[u] : 9;//若上一位达到限制，当前位也有限制，否则 0 ~ 9 都可以填
for(int i = 0; i <= up; i ++)//枚举当前位填什么
{
//如果前几位都取到上限后一位必须取上限
res += dfs(u - 1, sum + i, (mod * 10 + i) % p, limit && i == up);
}
return limit ? res : f[u][sum][mod] = res;
}
int solve(int n)//计算1-n中满足条件的数(月之数)的个数
{
int cnt = 0;
while(n)
{
num[++ cnt] = n % 10;//每位数的上限
n /= 10;
}
int res = 0;
for(p = 1; p < maxn; p ++)//枚举所有可能数位之和 10 * 9 = 90
{
memset(f, -1,sizeof f);
res += dfs(cnt, 0, 0, 1);
}
return res;
}
signed main()
{
int l,r;
cin >> l >> r;
cout << solve(r) - solve(l - 1) << endl;
return 0;
}8.打鼹鼠（牛客）
用f[ i ] 表示从前 i 个鼹鼠中选的最大数列
能够转移等价于两个鼹鼠之间的距离 <= 后一个鼹鼠出现的时间 - 前一个鼹鼠出现的时间
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10;
int f[N], n, m;
struct node
{
int t, x, y;
}mi[N];
bool check(int a, int b)
{
int t = mi[a].t - mi[b].t;
int w = abs(mi[a].x - mi[b].x) + abs(mi[a].y - mi[b].y);
return t >= w;
}
int main()
{
cin >> n >> m;
for(int i = 1; i <= m; i ++)
{
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
mi[i] = {t, x, y};
f[i] = 1;
for(int j = 1; j < i; j ++)
if(check(i, j)) f[i] = max(f[i], f[j] + 1);
}
int res = 0;
for(int i = 1; i <= m; i ++) res = max(res, f[i]);
cout << res << endl;
return 0;
}
