－
这周动态规划的训练结束了。回想下在做题时遇到的这样那样的问题，感觉在减少程序的时间复杂度上还是有一定困难。我也搜了好多有关减少时间复杂度的方法，但并不全面，不过还是有不少有用的东西的，也能够找到很多意想不到的解决方法，比如：
https://blog.csdn.net/qq_39861188/article/details/84245858
当然，还有很多描述什么是算法的时间复杂度以及怎样计算的，但但多语言比较专业，半懂不懂，但总的来说还是有所收获的。
回到重点，动态规划，这周在做题时我总在寻找着动态规划和递推的区别。开始的时候我甚至觉得，动态规划是包含递推的，或者说，递推是一种方法，然后动态规划处理问题时要用到递推，就像递归函数与递归这一算法一样。但在做题时却能感觉出有些许不同，不是难了，而是得出方程的途径，或者说出发点不同。动态规划是根据实际问题，分析状态变化间的关系，找出前后状态变化时数据间的练习，重在变化，而且强调此项（称它为项是因为这个结构很像是数列，通项公式什么的）与前面项间存在的现实关系，而递推更似数列，重在找寻前后项数值上存在的关系。其实表示起来还是如出一辙，不过出发点不同，处理问题的步骤路径不同，能够处理的问题也不尽然相同。确实很多问题两种思考方法都能够解出，甚至得出的递推公式或者状态转移方程也完全相同，但做题时是脑回路不同，能够应对更多变的题目。
或许知道这个在实际解题时作用不是很大，但更能够理解这所谓的态规划可不是因为那个变量或者数组叫ｄｐ，而是因为因为你以审视状态的目光去看这个题目，进而将问题分解得出状态转移方程，而不是机械的建立一个叫ｄｐ的变量或者数组然后机械的寻找能够满足题目要求的某个状态转移方程。状态转移方程不是找出来的，而是在分析问题的过程中自然而然的得出来的，有前一个状态才有后一个状态，才能有状态转移间的关系，而不是有了前后数据才找到了状态间的关系。
废话挺多的，还是看题目吧：
自从见识了平安夜苹果的涨价后，Lele就在他家门口水平种了一排苹果树，共有N棵。
突然Lele发现在左起第P棵树上(从1开始计数)有一条毛毛虫。为了看到毛毛虫变蝴蝶的过程，Lele在苹果树旁观察了很久。虽然没有看到蝴蝶，但Lele发现了一个规律：每过1分钟，毛毛虫会随机从一棵树爬到相邻的一棵树上。
比如刚开始毛毛虫在第2棵树上，过1分钟后，毛毛虫可能会在第1棵树上或者第3棵树上。如果刚开始时毛毛虫在第1棵树上，过1分钟以后，毛毛虫一定会在第2棵树上。
现在告诉你苹果树的数目N，以及毛毛刚开始所在的位置P，请问，在M分钟后，毛毛虫到达第T棵树，一共有多少种行走方案数。
Input
本题目包含多组测试，请处理到文件结束(EOF)。
每组测试占一行，包括四个正整数N,P,M,T(含义见题目描述，0<N,P,M,T<100)
Output
对于每组数据，在一行里输出一共的方案数。
题目数据保证答案小于10^9
Sample Input
3 2 4 2
3 2 3 2
Sample Output
4
0
Hint
第一组测试中有以下四种走法：
2->1->2->1->2
2->1->2->3->2
2->3->2->1->2
2->3->2->3->2
－
最早先，我做题的方式是先看给出示例的输入输出，然后自己再造出几组正常或者特殊的数据情况，然后找寻他们得出结果的规律，进而找出状态变化的关系，进而得出状态转移方程。这样做固然能得到一些题目的答案，但过程却还在沿用递推时的路子，应付些较简单的题目还可以蒙混过关，但遇到稍有水平的题目就歇菜了，还是得找对路子呀。
在看到这个题时，先去寻找状态，找到什么可以作为状态，然后确定什么作为状态。题目中，开始有个起始位置，经过一定时间会发生位置变换，求到时间结束时到达某一位置的方法数。
由此看来，这个题目可以作为状态的参数无非有两条线路，一个是位置，一个是时间。由一个起始位置每次向一个相邻位置移动，下次移动就是在上一次移动的基础上重复相同的移动方式，这种走法就像是一棵树的树杈，纵向延伸扩展而横向是某一条路线可行的结果。
如果以位置为状态，那么状态的变换只能是纵向的，要找寻不同路径走向某一终点的方法数目，而此状态的参数便是树木的标号和进行的时间，ｄｐ［ｉ］［ｊ］ｉ表示树木位置ｊ表示进行到的时间，即第ｉ棵树到j时刻时能够以第ｉ棵树为终点的方法数。那么现在这个状态的前一个状态，我已经找不到了。是ｄｐ［ｉ－１］［ｊ］？不是，因为相邻两棵树在某时刻可能到达的方法数就像两个由起点而来的两个菱形作用域，虽有交叉但没有什么有价值的联系。是ｄｐ［ｉ］［ｊ－１］？还是不行，因为这棵树再上一个时刻的下一步肯定不是这棵树。那是ｄｐ［ｉ－１］［ｊ－１］和ｄｐ［ｉ＋１］［ｊ－１］？讲得通，但实际上已经不再以位置为状态了，而是接下来的以时间为状态了，而且，这样一个状态转移方程，ｆｏｒ循环该怎么写呀，细想一下就知道行不通。
所以如果以时间为状态，状态的变换就是横向的，要寻找的就是某一时刻走向所有位置的方法数，而这一状态的参数同样还是进行的时间和数目的标号ｄｐ［ｉ］［ｊ］，只不过顺序颠倒，ｉ表示时间，ｊ表示树木位置。这样，ｄｐ［ｉ］［ｊ］的上一个状态就自然而然的是ｄｐ［ｉ－１］［ｊ＋１］和ｄｐ［ｉ－１］［ｊ－１］了。讲得通，而且可以实现。
其实这个题目不算难，但我挑这个题目是因为这一类型题目很常见，还有一个原因是这个题目的代码，我试着运用了下滚动数组的方法，以下是代码：
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
using namespace std;
int main()
{
cin.tie(0);
ios::sync_with_stdio(0);
int n,m,s,d,a[2][110];
for(;cin>>m>>n>>s>>d;)
{
memset(a,0,sizeof(a));
a[0][n]=1;
for(int i=1;i<=s;i++)
{
for(int j=1;j<=m;j++)
{
a[i%2][j]=a[(i+1)%2][j-1]+a[(i+1)%2][j+1];
}
}
cout<<a[s%2][d]<<endl;
}
}
－
建立了一个二维数组，而第一个维度只有０和１，正好对应时刻的奇偶性，通过模２来切换数组位置，表示前后时刻各树木上可能的走法数。所以说滚动数组最好的滚法就是利用下标，至于具体与谁打配合，还要看具体题目了。
再看一个陷入误区的题目：
Dynamic Programming, short for DP, is the favorite of iSea. It is a method for solving complex problems by breaking them down into simpler sub-problems. It is applicable to problems exhibiting the properties of overlapping sub-problems which are only slightly smaller and optimal substructure.
Ok, here is the problem. Given an array with N integers, find a continuous subsequence whose sum’s absolute value is the smallest. Very typical DP problem, right?
Input
The first line contains a single integer T, indicating the number of test cases.
Each test case includes an integer N. Then a line with N integers Ai follows.
Technical Specification
- 1 <= T <= 100
- 1 <= N <= 1 000
- -100 000 <= Ai <= 100 000
Output
For each test case, output the case number first, then the smallest absolute value of sum.
Sample Input
2
2
1 -1
4
1 2 1 -2
Sample Output
Case 1: 0
Case 2: 1
－
看到这个题目，瞬间让人想到经典的最大子段和问题，所以就想着在原先算法上进行修改就可以达到预期目的。题目的变化是求最小子段绝对值，那么也就是说小于零时同样表示一个大小，即相反数的大小。那么这一状态就使其达到在包含这一个数的情况下尽量小就可以了。这一状态可以是前面子段再加上这个数或者单单这个数作为一个新的子段。如果前面子段与这个数同号，那免谈，肯定还是这个数自己小。如果异号，那么就做一下比较，留下较小的。这样，就可以得出最后的结果了。看似完美，其实ｗａ，下面是它的代码：
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
typedef long long ll;
using namespace std;
int main()
{
cin.tie(0);
ios::sync_with_stdio(0);
int dp[1010],minn,n,x,a[1010];
cin>>x;
for(int o=1;o<=x;o++)
{
cin>>n;
minn=0x3f3f3f3f;
for(int i=1;i<=n;i++)
{
cin>>a[i];
if(i==1) dp[i]=a[i];
else if(a[i]*dp[i-1]<0&&abs(dp[i-1]+a[i])<abs(a[i]))
dp[i]=dp[i-1]+a[i];
else
dp[i]=a[i];
if(abs(minn)>abs(dp[i])) minn=dp[i];
}
cout<<"Case "<<o<<": "<<abs(minn)<<endl;
}
}
－
错在哪里呢？其实错在了这一算法最基本的要求，无后效性。假设前面和为－９，当前这个数是５，程序当然会将当前最优解得出为５，那如果下一个数是５呢，下一个最优解又会得出一个５，而如果－９＋５得出－４，再加上这个５呢，结果是１，程序完美的避开了正确答案。难道要看一下下一个数？那如果不是下一个数是５，而是接下来好几个数加起来是五呢？完全有可能躲避开正确答案，难道要检索到数组最后？当前状态的最优解与后面状态有关，所以，我也不知道这一算法怎么修改了，于是去搜了一下，完全找不到这样处理的题解，或许这一算法误解吧。不过搜到的所有题解都在说，暴力解题！所以：
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
typedef long long ll;
using namespace std;
int main()
{
cin.tie(0);
ios::sync_with_stdio(0);
int dp,minn,n,x,a[1010];
cin>>x;
for(int o=1;o<=x;o++)
{
cin>>n;
minn=0x3f3f3f3f;
for(int i=1;i<=n;i++)
cin>>a[i];
for(int i=1;i<=n;i++)
{
dp=0;
for(int j=i;j<=n;j++)
{
dp+=a[j];
minn=min(minn,abs(dp));
}
}
cout<<"Case "<<o<<": "<<minn<<endl;
}
}
－
很ｌｏｗ吧，但它是对的。再回来看下这个题目，发现题目的数据范围隐隐暗示了此题可以暴力求解，好吧。。。
再看一个至今未解决的题目。
Bob is a strategy game programming specialist. In his new city building game the gaming environment is as follows: a city is built up by areas, in which there are streets, trees,factories and buildings. There is still some space in the area that is unoccupied. The strategic task of his game is to win as much rent money from these free spaces. To win rent money you must erect buildings, that can only be rectangular, as long and wide as you can. Bob is trying to find a way to build the biggest possible building in each area. But he comes across some problems – he is not allowed to destroy already existing buildings, trees, factories and streets in the area he is building in.
Each area has its width and length. The area is divided into a grid of equal square units.The rent paid for each unit on which you’re building stands is 3$.
Your task is to help Bob solve this problem. The whole city is divided into K areas. Each one of the areas is rectangular and has a different grid size with its own length M and width N.The existing occupied units are marked with the symbol R. The unoccupied units are marked with the symbol F.
Input
The first line of the input contains an integer K – determining the number of datasets. Next lines contain the area descriptions. One description is defined in the following way: The first line contains two integers-area length M<=1000 and width N<=1000, separated by a blank space. The next M lines contain N symbols that mark the reserved or free grid units,separated by a blank space. The symbols used are:
R – reserved unit
F – free unit
In the end of each area description there is a separating line.
Output
For each data set in the input print on a separate line, on the standard output, the integer that represents the profit obtained by erecting the largest building in the area encoded by the data set.
Sample Input
2
5 6
R F F F F F
F F F F F F
R R R F F F
F F F F F F
F F F F F F
5 5
R R R R R
R R R R R
R R R R R
R R R R R
R R R R R
Sample Output
45
0
－
这个题我联想到了最大子矩阵和的题目。同样的降维压缩，得到的一维数组中储存的是这一列中有没有建筑物，能不能形成这么个子矩阵，最终求得最大的子矩阵。但代码超时，在晚上搜题解，但没找到有这么想的，下面是代码，希望有大佬可以帮忙解决吧。
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
#include<cstdio>
using namespace std;
int n,w,l,maxx,maxa,b[1010],c[1010];
char a[1010][1010];
int main()
{
scanf("%d",&n);
for(register int O=1;O<=n;++O)
{
maxx=0;
scanf("%d%d",&l,&w);
for(register int i=1;i<=l;++i)
for(register int j=1;j<=w;++j)
scanf(" %c",&a[i][j]);
for(register int i=1;i<=l;++i)
{
memset(b,0,sizeof(b));
memset(c,0,sizeof(c));
for(register int j=i;j<=l;++j)
{
maxa=0;
for(register int k=1;k<=w;++k)
{
if(a[j][k]=='R') b[k]=1;
c[k]=0;
if(b[k]==0) c[k]=c[k-1]+1;
maxa=max(maxa,c[k]);
}
maxa=(j+1-i)*maxa;
maxx=max(maxa,maxx);
}
}
printf("%d\n",maxx*3);
}
}
－
又一个挺难的算法，丰富着知识，同样也多了更多的迷茫。羡慕那些风云大佬，处理各种题目游刃有余，但慢慢来，不服输，不放弃，没什么是不可能的，我还不至于衰到付出努力白干一场吧，哈哈。
扫一扫
865
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
