模板1

最优子矩阵

/*对于一个矩阵而言，如果我们将连续k行的元素纵向相加，并对相加后所得的数列求连续最大和，则此连

续最大和就是一个行数为k的最优子矩阵！
*/

#include<iostream>
using namespace std;
int rec[101][101];
//int m=0;
//void get(int ans[101],int nums)
//{
//    int b = 0;
//    for(int i=0;i<nums;i++)
//    {
//        if(b<0)
//            b = ans[i];
//        else
//            b +=ans[i];
//        if(b>m)
//            m = b;
//    }
//}
int main()
{
    int nums;
    int result[101];
    cin>>nums;
    int m=0;
    for(int i=0;i<nums;i++)
    {
        for(int j=0;j<nums;j++)
        {
            cin>>rec[i][j];
        }
    }
    for(int i=0;i<nums;i++)
    {
        memset(result,0,sizeof(result));
        for(int j=i;j<nums;j++)
        {            
            int b = 0;
            for(int k=0;k<=nums;k++)
            {
                result[k]+=rec[j][k];
                if(b<=0)
                    b = result[k];
                else
                    b +=result[k];
                if(b>m)
                    m=b;
            }

        }
    }
    cout<<m<<endl;
    return 0;
}

括号匹配

/*
括号匹配问题
前i个中 ) 的个数为 j个。
初始化，dp[1][0]=1;

设立 j 为 ) 比 ( 更加简单

*/

#include<stdio.h>
int dp[20][20];

int main()
{
    int i,j,n;
    while(scanf("%d",&n)>0)
    {
        if(n%2==1)
        {
            printf("0\n");
            continue;
        }
        dp[1][0]=1;
        for(i=2;i<=n;i++)
        {
            for(j=0;j<=i/2;j++)
            {
                dp[i][j]=dp[i-1][j]+dp[i-1][j-1];
            }
        }
        printf("%d\n",dp[n][n/2]);
    }
    return 0;
}

RMQ

/*

RMQ 求解区间最值问题。

  满足动态规范方程：
  dp[i][j]=min{ dp[i][j-1],dp[i+( 1<<(j-1) )][j-1]  }
  利用的是二分的思想，表示dp[i][j]，位置i开始，长度为j的最值
  分解成，dp[i][j-1] ，dp[i+( 1<<(j-1) )][j-1]

*/

#include<iostream>
#include<cstdlib>
#include<cstring>
#define N 1000
using namespace std;

int dp[N][N];
int A[N];

int hmin(int x,int y)
{
    return x>y? x:y;
}

int RMQ(int L,int R) //查询的操作
{
    int k=0;
    while(  (1<<(k+1))<=R-L+1 )k++;
    return hmin(dp[L][k-1],dp[L+(1<<(k-1))][k-1]);
}

void make_ini(int n)
{
    int i,j,L,R,M;
    for(i=1;i<=n;i++)  //初始化
        dp[0][i]=A[i];

    for(j=1;(1<<j)<=n;j++) //元素编号从 1 到 n
        for(i=1;i+j-1<=n;i++)
            dp[i][j]=hmin(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);

/*
    P198    
        
*/
    scanf("%d",&M);
    while(M--)
    {
        scanf("%d%d",&L,&R);
        printf("%d\n",RMQ(L,R));
    }
}

int main()
{
    int n,i;
    while(scanf("%d",&n)>0)
    {
        for(i=1;i<=n;i++)
            scanf("%d",&A[i]);
        make_ini(n);
    }
    return 0;
}

求二进制数中1的个数

#include<stdio.h>
int get(int i)
{
    int count=0;
    while(i)
    {
        ++count;
        i=(i-1)&i;
    }
    return count;
}
int main()
{
    int i;
    while(scanf("%d",&i)>0)
    {
        printf("%d\n",get(i));
    }
}

线段切割

/*
看了中学生的论文，
学 线段切割


线段
a. ___________________.b
  
    c.___________.d
     
*/

struct Line
{
    int a;    //线段起始点
    int b;    //线段终点
    int longint; //长度
};

bool Function(int a,int b,int c,int d) 
{
    if(a>=d || c>=b) return false;
    else return true;
}
//判断线段是否重叠。当满足a>=d || c>=b的时候，不满足.



void Cut(int Num,int c,int d)
{
    if(Line[Num].a<c) Add(Line[Num].a,c);
    if(d<Line[Num].b) Add(d,Line[Num].b);
    Delete(Num);
}
//切割线段过程。如最上方所示。

/*
线段
a. ___________________.b
  
    c.___________.d
*/


void Add(int a,int b)
{
    total++;
    Line[total].a=a;
    Line[total].b=b;
}
//将一条线段增加到线段集合中


void Delete(int Num)
{
    Line[Num]=Line[total];
    total--;
}
//线段的删除过程，可以将集合中最后一天线段
//移到要删除线段的位置

石子合并

/*
f(n3)超时，超空间。
*/

#include<stdio.h>
#include<stdlib.h>
int dp[10005][10005];
int sum[10005]={0};
int a[10005];
int mmin(int x,int y)
{
    if(x<y)
        return x;
    else return y;
}
int main()
{
    int n,i,j,k,len;
    while(scanf("%d",&n)>0)
    {
        if(n==0)break;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum[i]=sum[i-1]+a[i];
        }
        for(len=2;len<=n;len++)//长度
        {
            for(i=1;i<=n-len+1;i++) //起点
            {
                j=i+len-1; //终点
                dp[i][j]=0x7fff;
                for(k=1;k<j;k++)
                    dp[i][j]=mmin(dp[i][j],dp[i][k]+dp[k+1][j]-sum[i-1]+sum[j]);
            }
        }
        printf("%d\n",dp[1][n]);
    }
    return 0;
}