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. 【Android】完善Android学习（六：API 4.0）

    备注:之前Android入门学习的书籍使用的是杨丰盛的<Android应用开发揭秘>,这本书是基于Android 2.2API的,目前Android已经到4.4了,更新了很多的API,也增 ...

  2. Spring @Async的异常处理

    楼主在前面的2篇文章中,分别介绍了Java子线程中通用的异常处理,以及Spring web应用中的异常处理.链接如下: Java子线程中的异常处理(通用) Spring web引用中的异常处理 今天, ...

  3. django中处理表单的经典流程

    def form_process_view(request): if request.method == 'POST': # 请求为 POST,利用用户提交的数据构造一个绑定了数据的表单 form = ...

  4. jsp 内置对象二

    1.什么是session ? (1)session 表示客户端与服务器的一次回话. 2)Web中的session指的是用户在浏览某个网站时,从进入网站到浏览器关闭所经过的这段时间,也就是用户浏览这个网 ...

  5. leaflet一个前端gis框架，比openlayer更简单

    leaflet一个前端gis框架,比openlayer更简单 作者github:https://github.com/mourner?tab=overview&from=2009-12-01& ...

  6. 【HDU】2222 Keywords Search

    [算法]AC自动机 [题解]本题注意题意是多少关键字能匹配而不是能匹配多少次,以及可能有重复单词. 询问时AC自动机与KMP最大的区别是因为建立了trie,所以对于目标串T与自动机串是否匹配只需要直接 ...

  7. 简易微信小程序签到功能

    一.效果图 点击签到后 二.数据库 用一张数据表存用户签到的信息,每次用户签到都会往表中添加一条记录了用户id和签到日期的数据,如下图 三.后端 后端写两个接口,一个用于查询用户今日是否签到和签到记录 ...

  8. charles https抓包

    1. 配置 Charles 根证书 首先打开 Charles: Charles 启动界面 主界面 然后如下图操作:   之后会弹出钥匙串,如果不弹出,请自行打开钥匙串,如下图: 钥匙串 系统默认是不信 ...

  9. javascript 事件绑定

    一.最简单和向后兼容性最好的事件绑定方法是把事件绑定到元素标识的属性.事件属性名称由事件类型外加一个“on”前缀构成.这些属性也被称为事件处理器 <INPUT TYPE="text&q ...

  10. Java多线程学习（五）线程间通信知识点补充

    系列文章传送门: Java多线程学习(二)synchronized关键字(1) Java多线程学习(二)synchronized关键字(2) Java多线程学习(三)volatile关键字 Java多 ...