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（区间最优解）题目讲解总结的更多相关文章

  1. 区间DP入门题目合集

      区间DP主要思想是先在小区间取得最优解,然后小区间合并时更新大区间的最优解.       基本代码: //mst(dp,0) 初始化DP数组 ;i<=n;i++) { dp[i][i]=初始 ...

  2. 区间DP小结

    也写了好几天的区间DP了,这里稍微总结一下(感觉还是不怎么会啊!). 但是多多少少也有了点感悟: 一.在有了一点思路之后,一定要先确定好dp数组的含义,不要模糊不清地就去写状态转移方程. 二.还么想好 ...

  3. 区间dp总结篇

    前言:这两天没有写什么题目,把前两周做的有些意思的背包题和最长递增.公共子序列写了个总结.反过去写总结,总能让自己有一番收获......就区间dp来说,一开始我完全不明白它是怎么应用的,甚至于看解题报 ...

  4. 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) ...

  5. LG3205/BZOJ1996 「HNOI2010」合唱队 区间DP

    区间DP 区间DP: 显然是一个区间向左右拓展形成的下一个区间,具有包含关系,所以可以使用区间DP. 状态设计: 考虑和关路灯一样设计状态 因为不知道当前这个区间是从哪个区间拓展而来,即不知道这个区间 ...

  6. NYOJ 题目15 括号匹配（二）（区间DP）

    点我看题目 题意 : 中文题不详述. 思路 : 本来以为只是个小模拟,没想到是个区间DP,还是对DP不了解. DP[i][j]代表着从字符串 i 位置到 j 位置需要的最小括号匹配. 所以初始化的DP ...

  7. 编程之美2015资格赛 题目2 : 回文字符序列 [ 区间dp ]

    传送门 题目2 : 回文字符序列 时间限制:2000ms 单点时限:1000ms 内存限制:256MB 描述 给定字符串,求它的回文子序列个数.回文子序列反转字符顺序后仍然与原序列相同.例如字符串ab ...

  8. 【DP】区间DP入门

    在开始之前我要感谢y总,是他精彩的讲解才让我对区间DP有较深的认识. 简介 一般是线性结构上的对区间进行求解最值,计数的动态规划.大致思路是枚举断点,然后对断点两边求取最优解,然后进行合并从而得解. ...

  9. [kuangbin带你飞]专题二十二 区间DP

            ID Origin Title   17 / 60 Problem A ZOJ 3537 Cake   54 / 105 Problem B LightOJ 1422 Hallowee ...

随机推荐

  1. AngularJs学习——常用表单指令练习

    一.知识点 ng-show.ng-hide.ng-if(控制元素显示隐藏,区别在于ng-hide是是否显示隐藏元素,而ng-if是是否移除元素): ng-src.ng-class(为元素添加路径和cl ...

  2. 【C++对象模型】第五章 构造、解构、拷贝 语意学

    1.构造语义学 C++的构造函数可能内带大量的隐藏码,因为编译器会扩充每一个构造函数,扩充程度视 class 的继承体系而定.一般而言编译器所做的扩充操作大约如下: 所有虚基类成员构造函数必须被调用, ...

  3. 归并排序Merge sort2

    原理,把原始数组分成若干子数组,对每一个子数组进行排序, 继续把子数组与子数组合并,合并后仍然有序,直到全部合并完,形成有序的数组 举例 无序数组[6 2 4 1 5 9] 先看一下每个步骤下的状态, ...

  4. 【LuoguP3038/[USACO11DEC]牧草种植Grass Planting】树链剖分+树状数组【树状数组的区间修改与区间查询】

    模拟题,可以用树链剖分+线段树维护. 但是学了一个厉害的..树状数组的区间修改与区间查询.. 分割线里面的是转载的: ----------------------------------------- ...

  5. 【BZOJ】1704: [Usaco2007 Mar]Face The Right Way 自动转身机

    [题意]n头牛,一些向前一些向后,每次可以使连续k头牛转身,求使旋转次数最小的k. [算法]贪心 [题解]这题题解很迷,大概思想是k没有单调性,故枚举k,从左到右扫描遇到一只向后的牛就旋转一次. 贪心 ...

  6. 【BZOJ】1574: [Usaco2009 Jan]地震损坏Damage

    [算法]搜索 [题意]给定无向图,现在可能有一些点已经被删除,只给出信息是c个点不能到达结点1,求最少的不能到达结点1的个数(含已删除点). [题解] 真是一道奥妙重重的题目. 每个点不能到达结点1, ...

  7. 微信小程序setData子元素

    页面的数据中如果有子元素,如下图nowQuestion中的deleted元素 在小程序的setData中,不能直接用nowQuestion.deleted来设定它的值,而需要再定义一个变量承接 另外, ...

  8. 使用BackgroundWorker

    1,WPF应用程序为单线程模型(STAThread),所有UI控件都是主线程创建的,只有主线程能操作UI元素的显示. 2,其他工作线程要维护UI控件的显示,需调用主线程的Dispather,执行Inv ...

  9. PKUWC 2019 自闭记

    PKUWC 2019 自闭记 Day -1 考前天天在隔壁的物竞教室划水(雀魂,能和吉老师一起玩的游戏都是好游戏),没有做题. Day 0 早上8:16的高铁,到广州南居然要6个小时...不知道福州和 ...

  10. 74cms 注入exp

    遇到就瞎写了一个: #!/usr/bin/env python #encoding:utf-8 #by i3ekr import requests,optparse,re parse = optpar ...