线性结构上的动态规划--算法竞赛入门经典笔记

最新推荐文章于 2019-08-25 22:43:56 发布
最新推荐文章于 2019-08-25 22:43:56 发布
阅读量133 收藏
点赞数
文章标签： 数据结构与算法
原文链接：https://juejin.im/post/5a6f1a386fb9a01cb1396729
版权

本文为该书的笔记：刘汝佳. 算法竞赛入门经典.第2版[M]. 清华大学出版社, 2014.
动态规划的思想：从复杂的题目背景中抽象出状态表示，然后设计它们之间的转移。

最长上升子序列问题（LTS）

题目链接

状态： d(i) 表示以 i 为结尾的最长上升子序列的长度（即 A_i 必定为为子序列的最后一个）。 则状态传递函数为：

d(i)=max \left \{ 0,d(j)|j<i,A_j<A_i \right \}

如果需要打印字典序。
样例：

6
1 6 2 3 7 5
复制代码

输出：

4
1 2 3 5
复制代码

完整程序：

#define LOCAL
#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
//#include <stdio.h>
#include <cstdlib>
#include<time.h>
#include <ctype.h>
#include <sstream>
#include <assert.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#define MAXN 92


using namespace std;

int A[101];
int rem[101];
int main()
{
    #ifdef LOCAL
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif // LOCAL
    int dmax=0,cur=0;
    while(cin >> n&& n){
        memset(d,0,sizeof(d));

        for(int i=1;i<=n;i++){
            cin >> A[i];
        }
        for(int i=1;i<=n;i++){
            d[i]=1;
            for(int j=1;j<i;j++){
                if(A[j]<A[i]){
                    d[i]=max(d[i],d[j]+1);
                }
            }
        }
        for(int i=1;i<=n;i++){
            if(d[i]>dmax){
                cur=i;
                dmax=d[i];
            }
        }
        cout << dmax << endl;
        rem[d[cur]] = A[cur];
        while(d[cur]>1){
            for(int j=1;j<cur;j++){
                if(A[j]<A[cur] && d[j]+1 == d[cur]){
                    cur = j;
                    rem[d[cur]]=A[cur];
                }
            }
        }
        for(int i=1;i<=dmax;i++){
            cout << rem[i] << " ";
        }

  return 0;
}

复制代码

最长公共子序列问题（LCS）

一个数列 {\displaystyle S} ，如果分别是两个或多个已知数列的子序列，且是所有符合此条件序列中最长的，则 {\displaystyle S} 称为已知序列的最长公共子序列。

维基百科介绍
样例：

6 7
1 5 2 6 8 7
2 3 5 6 9 8 4
复制代码

输出：

3
复制代码

状态： d(i,j) 表示 A_1 , A_2 ... A_i 和 B_1 , B_2 ... B_j 的 LCS 。
状态转移方程：

d(i,j)= \begin{cases} d(i-1,j-1)+1 & \text{ , } A_i=A_j \\ max \left \{ d(i-1,j),d(i,j-1) \right \} & \text{ , } A_i \neq A_j \end{cases} 
#define LOCAL
#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <time.h>
#include <ctype.h>
#include <sstream>
#include <assert.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#define MAXN 92
using namespace std;

int C;
//int d[10002];
int d[101][101];
int n,m;


int V,W;
int A[101],B[101];
int rem[101];
int dp(int i,int j){
    if(i<=0 || j<=0){
        return 0;
    }
//    cout << i << " " << j << endl;
    int& ans=d[i][j];
    cout << ans << endl;
    if(ans != -1){
        return ans;
    }
    if(A[i] == B[j]){
        return ans=dp(i-1,j-1)+1;
    }
    return ans=max(dp(i-1,j),dp(i,j-1));
}
int main()
{
    #ifdef LOCAL
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif // LOCAL
    int dmax=0,cur=0;
    while(cin >> n >> m && n && m){
        memset(d,-1,sizeof(d));
        for(int i=1;i<=n;i++){
            cin >> A[i];
        }
        for(int j=1;j<=m;j++){
            cin >> B[j];
        }
        d[0][0]=d[0][1]=d[1][0]=0;
        cout << dp(n,m);

  return 0;
}

复制代码

照明系统设计（UVa11400）

样例：

2
54376 266 7 80
20986 679 2 50
复制代码

输出：

1176
复制代码

可以得到结论： A 灯泡换成 B 灯泡，要么全都换，要么全都不换。因为 如果A的一部分换成了B，电源的费用是没有变的，可能省下来的只有当B的灯泡费用小于A的时候的一部分灯泡费用，那么为什么不讲A的所有可以省的灯泡费用都省下来呢？
当 V_i<V_j 且 K_i-(C_j-C_i)L_i>0 （即 \frac{ K_i}{L_i} +C_i>C_j ）时更换。
即如果i可以换成j，j可以换成k，则i则需要换成k。

先把灯泡按照电压从小到大排序，设 s_i 为前 i 种灯泡的总数量。
状态： d[i] 为前 i 种灯泡的最小开销
状态转移方程：

d[i]=min \left \{ d[j]+(s[i]-s[j])*C[i]+K[i] \right \}

其中 (s[i]-s[j])*C[i]+K[i] 为将第 i+1 ， i+2 ... j都换成 j 灯泡之后的开销， (s[i]-s[j])*C[i] 为转换之后这部分的灯泡总费用，

完整程序：

#define LOCAL
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>//操作字符串和数组
#define MAXN 1002

using namespace std;

int n;

int d[MAXN];
int s[MAXN];
struct Lamp{
    int v,k,c,l;
    bool operator < (const Lamp& var){
        return v<var.v;
    }
};
Lamp lamp[MAXN];
int dp(int i){
    int& ans=d[i];
    if(ans != -1){
        return ans;
    }
    ans=s[i]*lamp[i].c+lamp[i].k;
    for(int j=1;j<i;j++){
        ans=min(ans,dp(j)+(s[i]-s[j])*lamp[i].c+lamp[i].k);
    }
    return ans;
}

int main()
{
    #ifdef LOCAL
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif // LOCAL
    while(cin >> n && n){
        memset(d,-1,sizeof(d));
//        cin >> C;
        for(int i=1;i<=n;i++){
            cin >> lamp[i].v >> lamp[i].k >> lamp[i].c >> lamp[i].l;
        }
        sort(lamp+1,lamp+n+1);
        s[1]=lamp[1].l;
        for(int i=2;i<=n;i++){
            s[i]=s[i-1]+lamp[i].l;
        }
        cout << dp(n) << endl;
  return 0;
}

复制代码

划分成回文串（UVa11584）
状态不难想到，困难的是状态转移方程的确定。
状态： d[i] 为字符0~ i划分成的最小回文串个数。
状态转移方程：

d[i]=min{d[j]+1|s[j+1~i]是回文串}
复制代码

使用动态规划判断是s[i~j]是否为回文串： 状态：b[i][j]为bool型，表示i~j为回文串。

b[i][j]=(s[i] == s[j]) && b[i+1][j-1]
复制代码

完整程序:

#define LOCAL
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring> //操作字符串和数组
#define MAXN 1002


using namespace std;

const int INF = 1 << 30;

int C;

int n, m;

string s;
int b[MAXN][MAXN];
int d[MAXN];
int bp(int i, int j)
{
    int &ans = b[i][j];
    if (ans != -1)
        return ans;
    if (i == j)
        return ans = 1;
    if (i > j)
        return 1;
    if (s[i] == s[j] && bp(i + 1, j - 1))
    {
        return ans = 1;
    }
    else
    {
        return ans = 0;
    }
}
int dp(int i)
{
    int &ans = d[i];
    if (ans != -1)
    {
        return ans;
    }
    if (bp(0, i))
    {
        ans = 1;
    }
    else
    {
        ans = INF;
    }
    for (int j = 0; j < i; j++)
    {
        if (bp(j + 1, i))
        {
            ans = min(ans, dp(j) + 1);
        }
    }
    return ans;
}

int V, W;
int A[101], B[101];
int rem[101];
int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif // LOCAL
    int N;
    cin >> N;

    getline(cin, s);
    while (N--)
    {
        memset(b, -1, sizeof(b));
        memset(d, -1, sizeof(d));
        d[0] = 1;
        getline(cin, s);
        n = s.length();
        cout << dp(n - 1) << endl;
    }

    return 0;
}
复制代码

颜色的长度（UVa1625）

完整程序：

#define LOCAL
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring> //操作字符串和数组

using namespace std;
const int maxn = 5000 + 5;

const int INF = 1 << 30;

char p[maxn], q[maxn];              //p q为输入的字符序列
int n, m;                           //输入的两个序列的长度
int sp[26], ep[26], sq[26], eq[26]; //两个序列每个字母的起始和结束位置
int d[maxn][maxn];
int c[maxn][maxn];
/**< 有多少颜色已经开始但是尚未结束 */
int color(int i, int j)
{
    int c = 0;
    for (int ii = 0; ii < 26; ii++)
    {
        if ((sp[ii] <= i || sq[ii] <= j) && (ep[ii] > i || eq[ii] > j))
        {
            c++;
        }
    }
    return c;
}

/**<  p序列移走了前i个，q移走了前j个，这i+j个字符的跨度最小和*/
int dp(int i, int j)
{
    int &ans = d[i][j];
    if (ans != -1)
    {
        return ans;
    }
    if (!i && j)
    {
        ans = dp(i, j - 1) + c[i][j - 1];
    }
    else if (i && !j)
    {
        ans = dp(i - 1, j) + c[i - 1][j];
    }
    else
    {
        ans = min(dp(i - 1, j) + c[i - 1][j], dp(i, j - 1) + c[i][j - 1]);
    }
    //    cout <<i<<" "<<j<< " "<<ans <<endl;
    return ans;
}

int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);

#endif // LOCAL
    int N;
    cin >> N;
    while (N--)
    {
        memset(d, -1, sizeof(d));
        cin >> p + 1;
        cin >> q + 1;
        n = strlen(p + 1);
        m = strlen(q + 1);
        for (int i = 1; i <= n; i++)
        {
            p[i] -= 'A';
        }
        for (int i = 1; i <= m; i++)
        {
            q[i] -= 'A';
        }
        for (int i = 0; i < 26; i++)
        {
            sp[i] = sq[i] = INF;
            ep[i] = eq[i] = 0;
        }
        for (int i = 1; i <= n; i++)
        {
            sp[p[i]] = min(sp[p[i]], i);
            ep[p[i]] = i;
        }
        for (int i = 1; i <= m; i++)
        {
            sq[q[i]] = min(sq[q[i]], i);
            eq[q[i]] = i;
        }
        d[0][0] = 0;
        for (int i = 0; i <= n; i++)
            for (int j = 0; j <= m; j++)
            {
                c[i][j] = color(i, j);
            }
        cout << dp(n, m) << endl;
    }

    return 0;
}
复制代码

最优矩阵链乘

假设第 i 个矩阵 A_i 是 p_{i-1} \times p_i
状态 f(i,j) 表示：“把 A_i ， A_{i+1} ， ... ， A_j乘起来最少需要多少次乘法”。 状态转移方程：

f(i,j)=min \left \{ f(i,k)+f(k+1,j)+p_{i-1} p_k p_j \right \}

样例：

3
2 3 4 5
复制代码

结果：

64
复制代码

完整程序：
记忆化搜索：

#define LOCAL
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring> //操作字符串和数组

using namespace std;
const int maxn = 100 + 5;

const int INF = 1 << 30;
int p[maxn];
int d[maxn][maxn];
int n;
int dp(int i, int j)
{
    int &ans = d[i][j];
    if (ans != -1)
    {
        return ans;
    }
    ans = INF;
    for (int k = i; k <= j; k++)
    {
        ans = min(ans, dp(i, k) + dp(k + 1, j) + p[i - 1] * p[k] * p[j]);
    }
    return ans;
}
int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif // LOCAL
    while (cin >> n && n)
    {
        memset(d, -1, sizeof(d));
        for (int i = 0; i <= n; i++)
        {
            cin >> p[i];
            d[i][i] = 0;
        }
        cout << dp(1, n) << endl;
    }
    return 0;
}
复制代码

递推法：

#define LOCAL
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring> //操作字符串和数组

using namespace std;
const int maxn = 100 + 5;

const int INF = 1 << 30;
int p[maxn];
int d[maxn][maxn];
int n;
int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif // LOCAL
    while (cin >> n && n)
    {
        memset(d, -1, sizeof(d));
        for (int i = 0; i <= n; i++)
        {
            cin >> p[i];
            d[i][i] = 0;
        }
        for (int delta = 1; delta < n; delta++)
        {
            for (int i = 1; i + delta <= n; i++)
            {
                d[i][i + delta] = INF;
                for (int k = i; k <= i + delta; k++)
                {
                    d[i][i + delta] = min(d[i][i + delta], d[i][k] + d[k + 1][i + delta] + p[i - 1] * p[k] * p[i + delta]);
                }
            }
        }
        cout << d[1][n] << endl;
    }
    return 0;
}
复制代码

最优三角剖分

对于一个n个顶点的凸多边形，有很多种方法可以对它进行三角剖分（triangulation），即用n－3条互不相交的对角线把凸多边形分成n－2个三角形。为每个三角形规定一个权函数w(i, j,k)（如三角形的周长或3个顶点的权和），求让所有三角形权和最大的方案。

最优三角形剖分与最优矩阵链乘的不同：链乘表达式反映了决策过程，而剖分不反映决策过程，即在链乘问题里面对于某一解决策的过程是确定的，而在三角形剖分里面“第一刀”可以是这一个解里面的任何一条对角线。
如果允许随意切割，则半成品多边形的各个顶点可以在原多边形中任意选取的，很难简洁定义成状态。所以有必要把决策的顺序规范化，使得在规范的决策顺序下，任意状态都可以用区间表示。
定义 d(i,j) 为子多边形 i ， i+1 ， ... ， j 的最优值，则边 i-j在最优解中一定对应一个三角形 i-j-k ( i<k<j )。 状态转移方程：

d(i,j)=max \left \{ d(i,k)+d(k,j)+w(i,j,k)|i<k<j \right \}

原问题的解为 d(0,n-1) 。

切木棍（UVa10003）

状态： d(i,j) 为切割 i ~j$ 部分的最小费用。 状态转移方程：

d(i,j)=min \left \{ d(i,k)+d(k,j)+a_j-a_i|i<k<j \right \}

完整程序：

#define LOCAL
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring> //操作字符串和数组

using namespace std;
const int maxn = 50 + 3;

const int INF = 1 << 30;
int n;
int L;

int a[maxn];
int d[maxn][maxn];
int dp(int i,int j){
    if(j==i+1){
        return 0;
    }
    int& ans=d[i][j];
    if(ans != -1){
        return ans;
    }
    ans=INF;
    for(int k=i+1;k<j;k++){
        ans=min(ans,dp(i,k)+dp(k,j)+a[j]-a[i]);
    }
    return ans;
}
int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif // LOCAL
    while(cin >> L && L){
        memset(d,-1,sizeof(d));
        memset(a,0,sizeof(a));
        cin >> n;
        for(int i=1;i<=n;i++){
            cin >> a[i];
        }
        a[0]=0;
        a[n+1]=L;
        cout <<"The minimum cutting is "<< dp(0,n+1)<< "." << endl;
    }
    return 0;
}
复制代码

括号序列（UVa1626）：

定义如下正规括号序列（字符串）：

  • 空序列是正规括号序列。
  • 如果S是正规括号序列，那么(S)和[S]也是正规括号序列。
  • 如果A和B都是正规括号序列，那么AB也是正规括号序列。

例如，下面的字符串都是正规括号序列：()，[]，(())，([])，()[]，()[()]，而如下字符串则不是正规括号序列：(，[，]，)(，([()。
输入一个长度不超过100的，由“(”、“)”、“[”、“]”构成的序列，添加尽量少的括号，得到一个规则序列。如有多解，输出任意一个序列即可。

完整程序：

#define LOCAL
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring> //操作字符串和数组
#include <string>

using namespace std;
const int maxn = 100 + 3;

const int INF = 1 << 30;
int n;
string S;
int d[maxn][maxn];
int match(char a, char b)
{
    int c = 0;
    if (a == '(' && b == ')')
    {
        c = 1;
    }
    else if (a == '[' && b == ']')
    {
        c = 1;
    }
    return c;
}
int dp(int i, int j)
{

    int &ans = d[i][j];
    if (ans != -1)
    {
        return ans;
    }
    if (i > j)
        return ans = 0;
    if (i == j)
    {
        return ans = 1;
    }
    ans = INF;
    if (match(S[i], S[j]))
    {
        ans = dp(i + 1, j - 1);
    }
    for (int k = i; k < j; k++)
    {
        ans = min(ans, dp(i, k) + dp(k + 1, j));
    }
    return ans;
}
void print(int i, int j)
{
    if (i > j)
        return;
    if (i == j)
    {
        if (S[i] == '(' || S[i] == ')')
        {
            printf("()");
        }
        else
        {
            printf("[]");
        }
        return;
    }
    int ans = d[i][j];
    if (match(S[i], S[j]) && ans == d[i + 1][j - 1])
    {
        printf("%c", S[i]);
        print(i + 1, j - 1);
        printf("%c", S[j]);
        return;
    }
    for (int k = i; k < j; k++)
    {
        if (ans == d[i][k] + d[k + 1][j])
        {
            print(i, k);
            print(k + 1, j);
            return;
        }
    }
}
int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif // LOCAL
    int N;
    cin >> N;
    getline(cin, S);
    while (N--)
    {
        memset(d, -1, sizeof(d));
        getline(cin, S);
        getline(cin, S);
        int n = S.length();
        dp(0, n - 1);
        print(0, n - 1);
        cout << endl;
        cout << endl;
    }
    return 0;
}
复制代码

最大面积最小的三角剖分（UVa1331）

这实际是一个最优三角形剖分问题。
状态：设d(i,j)为子多边形 i ， i+1 ， ... ， j 的最优值(最大面积最小的三角形的最大面积)，则边 i-j 在最优解中一定对应一个三角形 i-j-k ( i<k<j )。 状态转移方程：

d(i,j)=min \left \{ max \left \{ d(i,k),d(k,j),w(i,j,k)\right \}|i<k<j \right \}

原问题的解为 d(0,n-1) 。 完整程序：

#define LOCAL
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring> //操作字符串和数组
#include <string>
#include <math.h>

using namespace std;
const int maxn = 50 + 2;
const int INF = 1 << 30;
int n;
double point[maxn][2];
double d[maxn][maxn];
int vis[maxn][maxn];
//求三角形的面积
double w(int a1, int b1, int c1)
{
    //求三条边长
    double a = sqrt(pow(point[a1][0] - point[b1][0], 2.0) + pow(point[a1][1] - point[b1][1], 2.0));
    double b = sqrt(pow(point[c1][0] - point[b1][0], 2.0) + pow(point[c1][1] - point[b1][1], 2.0));
    double c = sqrt(pow(point[a1][0] - point[c1][0], 2.0) + pow(point[a1][1] - point[c1][1], 2.0));
    double s = (a + b + c) / 2;
    double A = sqrt(s * (s - a) * (s - b) * (s - c));
    return A;
}
double dp(int i, int j)
{
    double area;
    double &ans = d[i][j];
    if (vis[i][j])
    {
        return ans;
    }
    if (j == i + 2)
    {
        vis[i][j] = 1;
        return ans = w(i, i + 1, j);
    }
    if (j == i + 1)
    {
        vis[i][j] = 1;
        return ans = 0;
    }
    ans = INF * 1.0;
    for (int k = i + 1; k <= j - 1; k++)
    {
        area = w(i, j, k);
        area = max(area, dp(i, k));
        area = max(area, dp(k, j));
        ans = min(ans, area);
    }
    vis[i][j] = 1;
    return ans;
}
int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif // LOCAL
    int N;
    cin >> N;
    while (N--)
    {
        memset(vis, 0, sizeof(vis));
        cin >> n;
        //输入点的值
        for (int i = 0; i < n; i++)
        {
            cin >> point[i][0] >> point[i][1];
        }
        //状态(0,n-1)的最优解
        cout << dp(0, n - 1) << endl;
    }
    return 0;
}
复制代码

转载于:https://juejin.im/post/5a6f1a386fb9a01cb1396729

weixin_33862188
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Algorithm-Daquan.rar_动态线性规划_动态规划_动态规划算法_数学规划_规划算法
07-14
包含线性规划，非线性规划，动态规划，图与网络等几个数学建模算法，对于初学者来说作用很大
算法入门竞赛经典 动态规划
m0_51373056的博客
11-03 489
动态规划入门 动态规划的第二个解法
线性结构上的动态规划
qq_36386435的博客
10-04 510
先看最长上升子序列： 用DP的思想完全可以解决： 动态规划法经常会遇到复杂问题不能简单地分解成几个子问题，而会分解出一系列的子问题。简单地采用把大问题分解成子问题，并综合子问题的解导出大问题的解的方法，问题求解耗时会按问题规模呈幂级数增加。为了节约重复求相同子问题的时间，引入一个数组，不管它们是否对最终解有用，把所有子问题的解存于该数组中，这就是动态规划法所采用的基本方法。但是时间复杂度是O(n
动态规划_线性结构上的DP
qq_30344173的博客
08-06 478
线性结构上的动态规划
NOIP算法总结——关于简单 线性动态规划
Gorden的博客
10-27 3292
动态规划，显然是一个很让人头疼的地方，也没有个固定的算法，最多就是有一些模板（比如背包啊），要是想要增大做出来的机率，也就只好多做做题找找感觉了~线性动态规划可以说是DP中最简单的类型了，当然里面很多也是不容易的题目，也是需要一点技巧了。搞了好几天了，现在就来总结一下。一、算法的选取，动态维护。例题1：最大子段和题目描述给出一段序列，选出其中连续且非空的一段使得这段和最大。输入输出格式输入格式：输入
非线性整数规划的遗传算法Matlab程序-综合文档
05-22
遗传算法（Genetic Algorithm, GA）是一种启发式搜索算法，灵感来源于生物进化过程，用于解决包括非线性整数规划在内的复杂优化问题。 在Matlab环境中实现非线性整数规划的遗传算法，首先需要理解遗传算法的基本...
数据结构与算法笔记-线性表定义和特点
01-07
# 对于非空线性表或者线性结构，其特点是： 存在唯一的一个被称作“第一个”的数据元素； 存在唯一的一个被称作“最后一个”的数据元素； 除第一个以外，结构中的每个数据元素均只有一个前驱； 除最后一个以，外结构...
算法竞赛入门经典授课教案
08-26
《算法竞赛入门经典授课教案》是一份专门为初学者设计的教育资源，旨在帮助学习者系统地理解和掌握算法竞赛的基础知识，并逐步提升在实际竞赛中的表现。这份教案深入浅出，覆盖了算法竞赛的关键概念，结合C语言进行...
算法竞赛专题解析--动态规划优化(1)四边形不等式1
最新发布
08-04
《算法竞赛入门到进阶》的第 7 章“动态规划”，讲解了 DP 的概念，以及线性 DP、区间DP、树形 DP、数位 DP、状态压缩 DP 等应用场景。本文以及后续
动态规划之线性动规
热门推荐
weixin_42430270的博客
06-20 1万+
动态规划之线性动规一、动态规划的基本概念动态规划是一种用途很广的问题求解方法，它本身并不是一个特定的算法，而是一种思想，一种手段。它的设计是对解最优化问题的一种途径、一种方法，而不是一种特殊算法。不像搜索或数值计算那样，具有一个标准的数学表达式和明确清晰的解题方法。动态规划程序设计往往是针对一种最优化问题，由于各种问题的性质不同，确定最优解的条件也互不相同，因而动态规划的设计方法对不同的问题，有各...
算法竞赛入门经典(第二版)-刘汝佳-第九章 动态规划初步 例题（11/31）
梁山伯的专栏
03-18 3704
说明本文是我对第9章31道例题的练习总结，建议配合紫书——《算法竞赛入门经典（第2版）》阅读本文。 另外为了方便做题，我在VOJ上开了一个contest，欢迎一起在上面做：第九章例题contest 如果想直接看某道题，请点开目录后点开相应的题目！！！例题例9-1 UVA 1025 地铁里的间谍题意思路代码例9-2 UVA 437 巴比伦塔题意思路代码例9-3 UVA 1347 旅游题意思路代码例
动态规划初步笔记
baidu_37352210的博客
01-19 329
刘汝佳. 算法竞赛入门经典 动态规划初步1,2两节的笔记
算法竞赛入门经典（第2版）—第九章（动态规划）
Accept1234的博客
08-25 338
文章目录零碎知识点题目1025 - A Spy in the Metro 零碎知识点 题目 1025 - A Spy in the Metro 题目链接：1025 - A Spy in the Metro 参考博文：UVA_1025_A_Spy_in_the_Metro_(动态规划) 题目大意：某城市的地铁是线性的,有n个车站,有M1辆列车从左到右开,M2辆列车从右到左开.在0时刻,你在第一站,...
动态规划入门 & 线性动态规划
益达的小作坊
08-04 840
参考文献：全国青少年信息学竞赛培训教材——复赛（陈合力 游光辉 编著） 一、概念在多阶段决策的问题中，各阶段采取的决策，一般俩说是与空间或者时间相关的。决策依赖于当前状态，又随即引起状态的转移，一个决策序列就是在变化的状态中产生出来，故有动态的含义。 我们称这种解决多阶段决策最优化的过程称为动态规划方法。 例如在一个m*n的迷宫中，从左下角走到右上角 可以看
算法竞赛入门经典：第八章 高效算法设计 8.1动态规划之最大连续和
qingyuanluofeng的专栏
08-18 782
/* 最大连续和: 给出一个长度为n的序列A1,A2,...,An,求最大连续和。换句话说，要求找到1<=i <= j<=n，使得Ai+Ai+1+..+Aj尽量大 b[i] = { b[i-1] + a,b[i-1] > 0 {a,b[i-1] <0 输入: 8 1 -2 3 10 -4 7 2 -5 输出: 18(3 10 -4 7 2) */ /*
算法竞赛入门经典--例题和课后训练（动态规划）
weixin_30443895的博客
04-04 135
1.地铁间谍（逆序推导时间法） 特工玛利亚被送到S市执行一个特别危险的任务。她需要利用地铁完成他的任务，S市的地铁只有一条线路运行，所以并不复杂。 玛利亚有一个任务，现在的时间为0，她要从第一个站出发，并在最后一站的间谍碰头。玛利亚知道有一个强大的组织正在追踪她，她知道如果一直呆在一个车站，她会有很大的被抓的风险，躲在运行的列车中是比较安全的。所以，她决定尽可能地呆在运行的列车...
动态规划初步 数字三角形（算法竞赛入门经典读书笔记）
王大头不吃藕的博客
02-14 438
问题简述： 如图示数字三角形。从第一行的数开始，每次可以往左下或右下走一步，直到走到最下行，把沿途经过的数全部加起来，如何走才能使得这个和尽量大？ 状态定义： 把每个数字的 当前位置(i,j) 表示如下： 这里定义几个状态：（务必理解这两个状态） a[ i ][ j ]： 存储对应位置的数值。如a[1][1]=1，a[2][1]=3。 d[ i ][ j ]： 从（i，j）出发时能得到的最大和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值