/*在数轴上有0-N的位置
从0出发每次可以向右走
2
23
233步*/
// 1 总共的方案数
f[i]=f[i-2]+f[i-23]+f[i-233];
f[0]=1;
for (int a=1;a<=n;a++)
{
if (a>=2) f[a]+=f[a-2];
if (a>=23) f[a]+=f[a-23];
if (a>=233) f[a]+=f[a-233];
}
printf("%d\n",f[n]);
// 2 考虑恰好t次到达时
//dp 题 可以考虑 每多一个条件 数组就多一维；所以，开二维数组
//f[i][j] 表示 用 j 步走了i种方案
f[i][j]=f[i-2][j-1]+f[i-23][j-1]+f[i-233][j-1];
f[0][0]=1;
for (int a=1;a<=n;a++)
for (int b=1;b<=t;b++)
{
if (a>=2) f[a][b]+=f[a-2][b-1];
if (a>=23) f[a][b]+=f[a-23][b-1];
if (a>=233) f[a][b]+=f[a-233][b-1];
}
printf("%d\n",f[n][t]);
int ans=0;
for (int a=0;a<=t;a++)
ans+=f[n][a];
printf("%d\n",ans);
// 3 考虑小于t次
//将
f[n][1]+f[n][2]+....f[n][t];
//考虑最多走r步233
//so 要再加一维，变成三维数组
//f[i][j][k] 表示走到 i点，公用j步，走233用了k步
f[i][j][k]=f[i-2][j-1][k]+ f[i-23][j-1][k]+ f[i-233][j-1][k-1];
/*
(N,M)的方格图
从(0,0)开始
只能朝右或上走
问走到(N,M)的方案数*/
//将每个点的左边点和下边点相加
f[n][m]=f[n-1][m]+f[n][m-1];
//考虑有k个点（x，y）不能走
//定义布尔数组记录每个不能坐的点
每次设f[x][y]=0，并加以判断；
//2.考虑每个坑只能掉一次：
if(不是坑)
F[i][j][k]=f[i-1][j][k]+f[i][j-1][k];
else if(是坑)
F[i][j][1]=f[i-1][j][0]-f[i][j-1][0];
#include<iostream>
using namespace std;
int main()
{
int n,i,j,a[101][101];
cin>>n;
for (i=1; i<=n; i++)
for (j=1; j<=i; j++)
cin>>a[i][j]; //输入数字三角形的值
for (i=n-1; i>=1; i--)
for (j=1; j<=i; j++)
{
if (a[i+1][j]>=a[i+1][j+1])
a[i][j]+=a[i+1][j]; //路径选择
else a[i][j]+=a[i+1][j+1];
}
cout<<a[1][1]<<endl;
}
int fib(int a)
{
if (!a) return 0;
if (a==1) return 1;
if (g[a]) return f[a];
g[a]=true;
f[a]=fib(a-1)+fib(a-2);
return f[a];
}
数字三角形问题，使得答案对p取模最大？
F[i][j][k] 表示走到第i行第j列 使得答案模p是否可行
F[i][j][k]=f[i+1][j][k-v[i][j]]
Or
F[i+1][j+1][k-v[i][j]]
**********代码：
for (int a=1;a<=n;a++)
f[n][a][v[n][a]%p]=true;
for (int a=n-1;a>=1;a--)
for (int b=1;b<=a;b++)
for (int c=0;c<p;c++)
f[a][b][c]=
f[a+1][b][(c-v[a][b]+p)%p] ||
f[a+1][b+1][(c-v[a][b]+p)%p];
int ans;
for (int a=p-1;a>=0;a--)
if (f[1][1][a])
{
ans=a;
break;
}
//***********区间DP********
/*合并石子
每次选择相邻两堆
代价为两堆石子和
问最小总代价
(第一层for循环一定要正着写)
因为后一层循环需要前一层循环的数据 */
F[l][r]=min(f[l][k]+f[k+1][r]+sum[l][r])
/*矩阵乘法
自定义顺序
使得运算次数最少*/
//F[i][j] 表示搞定[I,j]的最小代价
F[i][j] = min(f[i][k]+f[k][j+1]+cost(I,k,j))
