区间DP（区间最优解）题目讲解总结

1：给出一个括号字符串，问这个字符串中符合规则的最长子串的长度。

【分析】区间DP要覆盖整个区间，那么要求所有情况的并集。

先想出状态方程：

dp[i][j]：i ~ j区间内最大匹配数目

输出：dp[][n-]（从0开始）

区间DP最先想到的是就是：

.边界情况初始化

.for枚举区间长度，一般从第二个开始

.for枚举起点

.直接求得终点

.若括号匹配的情况，相当于外围是ok的，继续深入看内部，左端点右移&右端点左移+（因为外围匹配，数目+）

.一般情况就是枚举断点k，打擂台求匹配数目最大值

.输出整个区间的最大匹配数

【逆序枚举区间长度】

#include<cstdio>

#include<string>

#include<cstdlib>

#include<cmath>

#include<iostream>

#include<cstring>

#include<set>

#include<queue>

#include<algorithm>

#include<vector>

#include<map>

#include<cctype>

#include<stack>

#include<sstream>

#include<list>

#include<assert.h>

#include<bitset>

#include<numeric>

#define debug() puts("++++")

#define gcd(a,b) __gcd(a,b)

#define lson l,m,rt<<1

#define rson m+1,r,rt<<1|1

#define fi first

#define se second

#define pb push_back

#define sqr(x) ((x)*(x))

#define ms(a,b) memset(a,b,sizeof(a))

#define sz size()

#define be begin()

#define pu push_up

#define pd push_down

#define cl clear()

#define lowbit(x) -x&x

#define all 1,n,1

#define rep(i,x,n) for(int i=(x); i<=(n); i++)

using namespace std;

typedef long long LL;

typedef unsigned long long ULL;

typedef pair<int,int> P;

const int INF = 0x3f3f3f3f;

const LL LNF = 1e18;

const int maxm = 1e6 + ;

const double PI = acos(-1.0);

const double eps = 1e-;

const int dx[] = {-,,,,,,-,-};

const int dy[] = {,,,-,,-,,-};

int dir[][] = {{,},{,-},{-,},{,}};

const int mon[] = {, , , , , , , , , , , , };

const int monn[] = {, , , , , , , , , , , , };

const int mod = ;

#define inf 0x3f3f3f3f

#define ll long long

const int maxn = ;

int t,n,m,a[maxn],x,y,w;

int dp[][],ans;

string s;

int tot=;

/*

[题意]：给出一个括号字符串，问这个字符串中符合规则的最长子串的长度。

dp[i][j]:i~j区间内最大匹配数

输出：dp[1][n]

match:

dp[i][j] = dp[i+1][j-1]+2;

for(k:1..j)

dp[i][j] = max(dp[i][j],dp[i][k]+dp[k+1][j]);

((()))

()()()

([]])

)[)(

([][][)

end

6

6

4

0

6

*/

bool match(int L,int R)

{

    return s[L]=='('&&s[R]==')' || s[L]=='['&&s[R]==']';

}

int main()

{

    while(cin>>s)

    {

        if(s=="end") break;

        ms(dp,);

        n=s.size();

        for(int i=n-;i>=;i--)//枚举区间长度

        {

            for(int j=i+;j<n;j++)

            {

                if(match(i,j))

                    dp[i][j]=max(dp[i][j],dp[i+][j-]+);

                for(int k=i;k<j;k++)

                    dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+][j]);

            }

        }

        printf("%d\n",dp[][n-]);

    }

}

POJ - 2955 Brackets

【顺序】

#include<cstdio>

#include<string>

#include<cstdlib>

#include<cmath>

#include<iostream>

#include<cstring>

#include<set>

#include<queue>

#include<algorithm>

#include<vector>

#include<map>

#include<cctype>

#include<stack>

#include<sstream>

#include<list>

#include<assert.h>

#include<bitset>

#include<numeric>

#define debug() puts("++++")

#define gcd(a,b) __gcd(a,b)

#define lson l,m,rt<<1

#define rson m+1,r,rt<<1|1

#define fi first

#define se second

#define pb push_back

#define sqr(x) ((x)*(x))

#define ms(a,b) memset(a,b,sizeof(a))

#define sz size()

#define be begin()

#define pu push_up

#define pd push_down

#define cl clear()

#define lowbit(x) -x&x

#define all 1,n,1

#define rep(i,x,n) for(int i=(x); i<=(n); i++)

using namespace std;

typedef long long LL;

typedef unsigned long long ULL;

typedef pair<int,int> P;

const int INF = 0x3f3f3f3f;

const LL LNF = 1e18;

const int maxm = 1e6 + ;

const double PI = acos(-1.0);

const double eps = 1e-;

const int dx[] = {-,,,,,,-,-};

const int dy[] = {,,,-,,-,,-};

int dir[][] = {{,},{,-},{-,},{,}};

const int mon[] = {, , , , , , , , , , , , };

const int monn[] = {, , , , , , , , , , , , };

const int mod = ;

#define inf 0x3f3f3f3f

#define ll long long

const int maxn = ;

int t,n,m,a[maxn],x,y,w;

int dp[][],ans;

string s;

int tot=;

/*

[题意]：给出一个括号字符串，问这个字符串中符合规则的最长子串的长度。

dp[i][j]:i~j区间内最大匹配数

输出：dp[1][n]

match:

dp[i][j] = dp[i+1][j-1]+2;

for(k:1..j)

dp[i][j] = max(dp[i][j],dp[i][k]+dp[k+1][j]);

((()))

()()()

([]])

)[)(

([][][)

end

6

6

4

0

6

*/

bool match(int L,int R)

{

    return s[L]=='('&&s[R]==')' || s[L]=='['&&s[R]==']';

}

int main()

{

    while(cin>>s)

    {

        if(s=="end") break;

        ms(dp,);

        n=s.size();

        for(int l=;l<n;l++)//枚举区间长度

        {

            for(int i=;i+l<n;i++)//起点

            {

                int j=i+l;//终点

                if(match(i,j))

                    dp[i][j]=max(dp[i][j],dp[i+][j-]+);

                for(int k=i;k<j;k++)

                    dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+][j]);

            }

        }

        printf("%d\n",dp[][n-]);

    }

}

括号匹配

2：给你一串数字，头尾不能动，每次取出一个数字，这个数字贡献=该数字与左右相邻数字的乘积，求一个最小值。

【分析】类似一维的矩阵连乘

#include<cstdio>

#include<string>

#include<cstdlib>

#include<cmath>

#include<iostream>

#include<cstring>

#include<set>

#include<queue>

#include<algorithm>

#include<vector>

#include<map>

#include<cctype>

#include<stack>

#include<sstream>

#include<list>

#include<assert.h>

#include<bitset>

#include<numeric>

#define debug() puts("++++")

#define gcd(a,b) __gcd(a,b)

#define lson l,m,rt<<1

#define rson m+1,r,rt<<1|1

#define fi first

#define se second

#define pb push_back

#define sqr(x) ((x)*(x))

#define ms(a,b) memset(a,b,sizeof(a))

#define sz size()

#define be begin()

#define pu push_up

#define pd push_down

#define cl clear()

#define lowbit(x) -x&x

#define all 1,n,1

#define rep(i,x,n) for(int i=(x); i<=(n); i++)

using namespace std;

typedef long long LL;

typedef unsigned long long ULL;

typedef pair<int,int> P;

const int INF = 0x3f3f3f3f;

const LL LNF = 1e18;

const int maxm = 1e6 + ;

const double PI = acos(-1.0);

const double eps = 1e-;

const int dx[] = {-,,,,,,-,-};

const int dy[] = {,,,-,,-,,-};

int dir[][] = {{,},{,-},{-,},{,}};

const int mon[] = {, , , , , , , , , , , , };

const int monn[] = {, , , , , , , , , , , , };

const int mod = ;

#define inf 0x3f3f3f3f

#define ll long long

const int maxn = ;

int t,n,m,a[maxn],x,y,w;

int dp[][],ans;

string s;

int tot=;

/*

[题意]：给你一串数字，头尾不能动，每次取出一个数字，这个数字贡献=该数字与左右相邻数字的乘积，求一个最小值。

//类一维矩阵连乘

dp[i][j]:i~j区间内最小权值

输出：dp[1][n]

dp[i][j] = min(dp[i][j], dp[i][k]+dp[k+1][j]+a[i-1]*a[k]*a[j]);

6

10 1 50 50 20 5

3650

*/

int main()

{

   while(~scanf("%d",&n))

   {

       ms(dp,);//

       for(int i=;i<=n;i++)

       {

           scanf("%d",&a[i]);

       }

       for(int r=;r<=n;r++)

       {

           for(int i=;i+r-<=n;i++)

           {

               int j=i+r-;

               dp[i][j]=INF;//

               for(int k=i;k<j;k++)

                    dp[i][j]=min(dp[i][j], dp[i][k]+dp[k+][j]+a[i-]*a[k]*a[j]);

           }

       }

       printf("%d\n",dp[][n]);//

   }

}

POJ - 1651 Multiplication Puzzle

3：给你n天需要穿的衣服的样式，每次可以套着穿衣服，脱掉的衣服就不能再穿了，问至少要带多少条衣服才能参加所有宴会.

【分析】

dp[i][j]：i~j区间内所需最少衣服数目

输出：dp[1][n]

之后不再用到：
dp[i][j] = dp[i][j-1]+1;
之后还要用到并且把断点保留到终点：
dp[i][j] = max(dp[i][j], dp[i][k]+dp[k+1][j])

区间dp，dp[i][j]表示i~j天所需的最小数量。

考虑第j天穿不穿，如果穿的话那么 dp[i][j]=dp[i][j-1]+1;

如果不穿的话，那么需要有一个 k (i<=k<j)，第j天和第k天穿的衣服相同，将k+1~j-1衣服套着穿后全部脱掉，那么

dp[i][j]=dp[i][k]+dp[k+1][j-1]；

【顺序】

#include<cstdio>

#include<string>

#include<cstdlib>

#include<cmath>

#include<iostream>

#include<cstring>

#include<set>

#include<queue>

#include<algorithm>

#include<vector>

#include<map>

#include<cctype>

#include<stack>

#include<sstream>

#include<list>

#include<assert.h>

#include<bitset>

#include<numeric>

#define debug() puts("++++")

#define gcd(a,b) __gcd(a,b)

#define lson l,m,rt<<1

#define rson m+1,r,rt<<1|1

#define fi first

#define se second

#define pb push_back

#define sqr(x) ((x)*(x))

#define ms(a,b) memset(a,b,sizeof(a))

#define sz size()

#define be begin()

#define pu push_up

#define pd push_down

#define cl clear()

#define lowbit(x) -x&x

#define all 1,n,1

#define rep(i,x,n) for(int i=(x); i<=(n); i++)

using namespace std;

typedef long long LL;

typedef unsigned long long ULL;

typedef pair<int,int> P;

const int INF = 0x3f3f3f3f;

const LL LNF = 1e18;

const int maxm = 1e6 + ;

const double PI = acos(-1.0);

const double eps = 1e-;

const int dx[] = {-,,,,,,-,-};

const int dy[] = {,,,-,,-,,-};

int dir[][] = {{,},{,-},{-,},{,}};

const int mon[] = {, , , , , , , , , , , , };

const int monn[] = {, , , , , , , , , , , , };

const int mod = ;

#define inf 0x3f3f3f3f

#define ll long long

const int maxn = ;

int t,n,m,a[],x,y,w;

int dp[][],ans;

string s;

int tot=;

/*

[题意]：给你n天需要穿的衣服的样式，每次可以套着穿衣服，脱掉的衣服就不能再穿了，问至少要带多少条衣服才能参加所有宴会.

4

1 2 1 2

只需要先穿上1，然后再穿上2，再脱掉2，就穿着1了，接着此时没有2的衣服了，所以我们还需要一件2的衣服，所以最后总共是需要3件衣服。

dp[i][j]：i~j区间内所需最少衣服数目

输出：dp[1][n]

之后不再用到

dp[i][j] = dp[i][j-1]+1;

之后还要用到并且把断点保留到终点

dp[i][j] = max(dp[i][j], dp[i][k]+dp[k+1][j])

2

4

1 2 1 2

7

1 2 1 1 3 2 1

Case 1: 3

Case 2: 4

*/

int main()

{

   int cas=;

   scanf("%d",&t);

   while(t--)

   {

       scanf("%d",&n);

       ms(dp,);

       for(int i=;i<=n;i++)

           scanf("%d",&a[i]);

       rep(i,,n) dp[i][i]=;

       for(int r=;r<=n;r++)

       {

           for(int i=;i+r-<=n;i++)

           {

               int j=i+r-;

               dp[i][j] = dp[i][j-]+;//不需要上一场衣服

               for(int k=i; k<j; k++)

                //考虑是不是可以将i那件衣服在k这个地方重复利用

                    if(a[k] == a[j])//如果将第k场的衣服保留到第j场

                        dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+][j-]);

           }

       }

       printf("Case %d: %d\n",cas++,dp[][n]);//

   }

}

LightOJ - 1422 Halloween Costumes

【逆序】

#include<cstdio>

#include<string>

#include<cstdlib>

#include<cmath>

#include<iostream>

#include<cstring>

#include<set>

#include<queue>

#include<algorithm>

#include<vector>

#include<map>

#include<cctype>

#include<stack>

#include<sstream>

#include<list>

#include<assert.h>

#include<bitset>

#include<numeric>

#define debug() puts("++++")

#define gcd(a,b) __gcd(a,b)

#define lson l,m,rt<<1

#define rson m+1,r,rt<<1|1

#define fi first

#define se second

#define pb push_back

#define sqr(x) ((x)*(x))

#define ms(a,b) memset(a,b,sizeof(a))

#define sz size()

#define be begin()

#define pu push_up

#define pd push_down

#define cl clear()

#define lowbit(x) -x&x

#define all 1,n,1

#define rep(i,x,n) for(int i=(x); i<=(n); i++)

using namespace std;

typedef long long LL;

typedef unsigned long long ULL;

typedef pair<int,int> P;

const int INF = 0x3f3f3f3f;

const LL LNF = 1e18;

const int maxm = 1e6 + ;

const double PI = acos(-1.0);

const double eps = 1e-;

const int dx[] = {-,,,,,,-,-};

const int dy[] = {,,,-,,-,,-};

int dir[][] = {{,},{,-},{-,},{,}};

const int mon[] = {, , , , , , , , , , , , };

const int monn[] = {, , , , , , , , , , , , };

const int mod = ;

#define inf 0x3f3f3f3f

#define ll long long

const int maxn = ;

int t,n,m,a[],x,y,w;

int dp[][],ans;

string s;

int tot=;

/*

[题意]：给你n天需要穿的衣服的样式，每次可以套着穿衣服，脱掉的衣服就不能再穿了，问至少要带多少条衣服才能参加所有宴会.

4

1 2 1 2

只需要先穿上1，然后再穿上2，再脱掉2，就穿着1了，接着此时没有2的衣服了，所以我们还需要一件2的衣服，所以最后总共是需要3件衣服。

dp[i][j]：i~j区间内所需最少衣服数目

输出：dp[1][n]

之后不再用到

dp[i][j] = dp[i][j-1]+1;

之后还要用到并且把断点保留到终点

dp[i][j] = max(dp[i][j], dp[i][k]+dp[k+1][j])

2

4

1 2 1 2

7

1 2 1 1 3 2 1

Case 1: 3

Case 2: 4

*/

int main()

{

   int cas=;

   scanf("%d",&t);

   while(t--)

   {

       scanf("%d",&n);

       ms(dp,);

       for(int i=;i<=n;i++)

           scanf("%d",&a[i]);

        //如果无脑安排的话dp[i][j]=j-i+1，也就是区间长度。

       rep(i,,n) rep(j,i,n)

        dp[i][j]=j-i+;

       for(int i=n-;i>=;i--)

       {

           for(int j=i+;j<=n;j++)

           {

               dp[i][j] = dp[i+][j]+;//不需要上一场衣服

               for(int k=i+; k<=j; k++)

                //考虑是不是可以将i那件衣服在k这个地方重复利用

                    if(a[k] == a[i])//如果将第k场的衣服保留到第j场

                        dp[i][j] = min(dp[i][j], dp[i][k-] + dp[k+][j]);

           }

       }

       printf("Case %d: %d\n",cas++,dp[][n]);//

   }

}

逆序

4：给出n个数，每个数要先进栈然后出栈，第i个出栈的数a，花费的价值是(i-1)*a.问所有的数出栈花费的最小价值。

#include<cstdio>

#include<string>

#include<cstdlib>

#include<cmath>

#include<iostream>

#include<cstring>

#include<set>

#include<queue>

#include<algorithm>

#include<vector>

#include<map>

#include<cctype>

#include<stack>

#include<sstream>

#include<list>

#include<assert.h>

#include<bitset>

#include<numeric>

#define debug() puts("++++")

#define gcd(a,b) __gcd(a,b)

#define lson l,m,rt<<1

#define rson m+1,r,rt<<1|1

#define fi first

#define se second

#define pb push_back

#define sqr(x) ((x)*(x))

#define ms(a,b) memset(a,b,sizeof(a))

#define sz size()

#define be begin()

#define pu push_up

#define pd push_down

#define cl clear()

#define lowbit(x) -x&x

#define all 1,n,1

#define rep(i,x,n) for(int i=(x); i<=(n); i++)

using namespace std;

typedef long long LL;

typedef unsigned long long ULL;

typedef pair<int,int> P;

const int INF = 0x3f3f3f3f;

const LL LNF = 1e18;

const int maxm = 1e6 + ;

const double PI = acos(-1.0);

const double eps = 1e-;

const int dx[] = {-,,,,,,-,-};

const int dy[] = {,,,-,,-,,-};

int dir[][] = {{,},{,-},{-,},{,}};

const int mon[] = {, , , , , , , , , , , , };

const int monn[] = {, , , , , , , , , , , , };

const int mod = ;

#define inf 0x3f3f3f3f

#define ll long long

const int maxn = ;

int t,n,m,a[],sum[],x,y,w;

int dp[][],ans;

int tot=;

/*

[题意]：

题意：有n个人排成一排要上台表演，每个人有一个屌丝值ai。第i个上台表演的人，他的不满意度为(i-1)*ai。

现在有一个类似于栈的黑屋子，你可以让某些人进入这个黑屋子。这些人要按照排的顺序来，那么对于排在最前面的人，

就有两个选择：

（1）让他直接上台表演；

（2）让他暂时进黑屋子。

现在请你选择一个合理的调度顺序，使得最后的总不满意度最小？

——建模后就是：给出n个数，每个数要先进栈然后出栈，第i个出栈的数a，花费的价值是(i-1)*a.问所有的数出栈花费的最小价值是多少？

1 2 3 4 5 —— 20

5 4 3 2 1

0 4 6 6 4 = 20

5 4 3 2 2 —— 24

0 4 6 6 8 = 24

-----------------------------------------------------------

不妨设他是第k个出场的（1<=k<=j-i+1)，那么根据栈后进先出的特点，以及题目要求原先男的是排好序的，那么：：

第 i+1 到 i+k-1 总共有k-1个人要比i先出栈，

第 i+k 到 j 总共j-i-k+1个人在i后面出栈~

我们首先可以把小黑屋看成一个栈，如果我们枚举区间第k个人是第一个上场的话，我们仍然不知道

左右区间每个人的上场顺序，这样子左右区间就不是完全独立的了，不具备无后效性这个特点。

我们可以枚举第i个人是第k个上场的，那么区间[i+1,i+k−1]的k−1(j-i+1=i+k-1-i-1+1=k-1)个人一定是在i之前上场的，并且区间[i+k+1,j]的所有人一定是在i之后上场的，这样所有人的相对顺序就确定了.

对于子区间dp[i+k+1][j]，我们是把它单独处理的，也就是得到这个最优解时第一个上场的确实是第一个上场的，但是如果想要由它转移到dp[i][j],那么第一个人实际上是第k+1个上场的，第二个人实际上是第k+2个上场的......所以别忘了这种附加“属性”。

dp[i][j]：第i个人到第j个人这段区间的最小花费

输出：dp[1][n]

枚举出场次序k(1<=k<=n)

第i个人第k个出场：

前k个人：dp[i+1][i+k-1]

第k个人：(k-1)*a[i]

后k个人：dp[i+k][j] + sum[j] - sum[i+k-1]

*/

int main()

{

   int cas=;

   scanf("%d",&t);

   while(t--)

   {

       scanf("%d",&n);

       ms(dp,);ms(sum,);

       for(int i=;i<=n;i++)

       {

           scanf("%d",&a[i]);

           sum[i] = sum[i-] + a[i];

       }

       rep(i,,n) rep(j,i+,n)

        dp[i][j]=INF;

       for(int r=;r<=n;r++)

       {

           for(int i=;i+r-<=n;i++)

           {

               int j=i+r-;

               for(int k=; k<=n; k++)

               {

                   dp[i][j]=min(dp[i][j],dp[i+][i+k-]+dp[i+k][j]+(k-)*a[i]+k*(sum[j]-sum[i+k-]));

               }

           }

       }

       printf("Case #%d: %d\n",cas++,dp[][n]);

   }

}

/*

2　

5

1 2 3 4 5

5

5 4 3 2 2

Sample Output

Case #1: 20

Case #2: 24

*/

You Are the One HDU - 4283

区间DP（区间最优解）题目讲解总结的更多相关文章

区间DP入门题目合集
区间DP主要思想是先在小区间取得最优解,然后小区间合并时更新大区间的最优解. 基本代码: //mst(dp,0) 初始化DP数组 ;i<=n;i++) { dp[i][i]=初始 ...
区间DP小结
也写了好几天的区间DP了,这里稍微总结一下(感觉还是不怎么会啊!). 但是多多少少也有了点感悟: 一.在有了一点思路之后,一定要先确定好dp数组的含义,不要模糊不清地就去写状态转移方程. 二.还么想好 ...
区间dp总结篇
前言:这两天没有写什么题目,把前两周做的有些意思的背包题和最长递增.公共子序列写了个总结.反过去写总结,总能让自己有一番收获......就区间dp来说,一开始我完全不明白它是怎么应用的,甚至于看解题报 ...
2016 ACM/ICPC Asia Regional Shenyang Online 1009/HDU 5900 区间dp
QSC and Master Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others) ...
LG3205/BZOJ1996 「HNOI2010」合唱队区间DP
区间DP 区间DP: 显然是一个区间向左右拓展形成的下一个区间,具有包含关系,所以可以使用区间DP. 状态设计: 考虑和关路灯一样设计状态因为不知道当前这个区间是从哪个区间拓展而来,即不知道这个区间 ...
NYOJ 题目15 括号匹配（二）（区间DP）
点我看题目题意 : 中文题不详述. 思路 : 本来以为只是个小模拟,没想到是个区间DP,还是对DP不了解. DP[i][j]代表着从字符串 i 位置到 j 位置需要的最小括号匹配. 所以初始化的DP ...
编程之美2015资格赛题目2 : 回文字符序列 [ 区间dp ]
传送门题目2 : 回文字符序列时间限制:2000ms 单点时限:1000ms 内存限制:256MB 描述给定字符串,求它的回文子序列个数.回文子序列反转字符顺序后仍然与原序列相同.例如字符串ab ...
【DP】区间DP入门
在开始之前我要感谢y总,是他精彩的讲解才让我对区间DP有较深的认识. 简介一般是线性结构上的对区间进行求解最值,计数的动态规划.大致思路是枚举断点,然后对断点两边求取最优解,然后进行合并从而得解. ...
[kuangbin带你飞]专题二十二区间DP
ID Origin Title 17 / 60 Problem A ZOJ 3537 Cake 54 / 105 Problem B LightOJ 1422 Hallowee ...

随机推荐

Win7 安装配置 nexus3.7.1
安装准备: nexus3.7.1 环境准备: maven.jdk 解压nexus目录结构为: E:\nexus-3.7.1-02 配置环境变量: 启动: nexus.exe /run
2017-2018-2 20179207 《网络攻防技术》python简明教程（1-10）
Python3简明教程(一) 开始python之旅使用交互模式的 Python3解释器简单使用 vim 编写 Python3 脚本执行 Python3 脚本 Python3 代码风格建议 Pyt ...
Makefile $@，$^，$ 作用
/* main.c */ #include "mytool1.h" #include "mytool2.h" int ...
省队集训 Day7 选点游戏
[题目大意] 维护一个$n$个点的图,$m$个操作,支持两个操作: 1. 连接$(u, v)$这条边: 2. 询问$u$所在的联通块中,能选出的最大合法的点数. 一个方案是合法的,当且仅当对于所有被选 ...
【51NOD】1096 距离之和最小
[算法]数学 [题解] 其实就是求中位数,奇数个点就是最中间的点,偶数个点就是最中间两个点和它们之间的区域皆可(所以偶数不必取到两点正中央,取两点任意一点即可). 我们可以想象现在x轴上有n个点,我们 ...
SpringCloud Feign重试详解
摘要: 今天在生产环境发生了数据库进程卡死的现象,除了sql因为全量更新,没加索引的原因,最主要还是我们的接口的服务器端接口出现问题了.忽视了更新接口的幂等性,以及调用方feign client的重试 ...
Revison
KVM虚拟机建立快照
部分转载: http://blog.csdn.net/gg296231363/article/details/6899533 windows虚拟机默认镜像格式为raw,快照默认格式为qcow2.win ...
linux内核网络接收数据流程图【转】
转自:http://blog.chinaunix.net/uid-23069658-id-3141409.html 4.3 数据接收流程图各层主要函数以及位置功能说明: 1)s ...
Linux内核中链表的实现与应用【转】
转自:http://blog.chinaunix.net/uid-27037833-id-3237153.html 链表(循环双向链表)是Linux内核中最简单.最常用的一种数据结构. ...

区间DP（区间最优解）题目讲解总结

区间DP（区间最优解）题目讲解总结的更多相关文章

随机推荐

热门专题