草稿

Tyvj 1188 //矩阵连乘

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdio>
using namespace std;
const int MAX=25;
const int Inf=1000010;
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int n,a[MAX],DP[MAX][MAX],sum[MAX][MAX],Path[MAX][MAX];
void Fun()
{   for(int r=2;r<=n;r++)
        for(int i=1;i<=n-r+1;i++)
        {    int j=r+i-1;
             for(int k=i;k<j;k++)
             {   int t=DP[i][k]+DP[k+1][j]+sum[i][j];
                 if(t<DP[i][j])
                 {   DP[i][j]=t;
                     Path[i][j]=k; //从k位置隔开
                 }
             }               
        }
}
void Find(int L,int R)
{  
    if(L==R)
    {   cout<<a[L]<<"+";
        return ;
    }
    if(L<Path[L][R]) cout<<"(";
    Find(L,Path[L][R]);
    if(L<Path[L][R]) cout<<")";
    if(Path[L][R]+1<R) cout<<"(";
    Find(Path[L][R]+1,R);
    if(Path[L][R]+1<R)  cout<<")";

}
int main()
{   scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);   
    CLR(sum,0);
    for(int i=1;i<=n;i++)
        for(int j=i;j<=n;j++)
            sum[i][j]=sum[i][j-1]+a[j]; //sum[i][j]保存区间[i,j]的元素之和
    for(int i=1;i<=n;i++)
        fill(DP[i],DP[i]+MAX,Inf);
    for(int i=1;i<=n;i++) DP[i][i]=0;   
    Fun(); 
    cout<<"(";
    Find(1,n);
    cout<<")"<<endl;    
    cout<<DP[1][n]<<endl;   
    system("pause");
    return 0;
}

 

NYOJ 568

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;
const int MAX=100010;
#define Lson L,mid,root
#define Rson mid+1,L,root
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int Min[MAX];
void Pushup(int root)
{   Min[root]=min(Min[root>>1],Min[root>>1|1]);
}
void Bulid(int L,int R,int root)
{   if(L==R)
    {   scanf("%d",&Min[root]);
    }
    int mid=(L+R)>>1;
    Bulid(Lson);
    Bulid(Rson);
    Pushup(root);
}
int main()
{
    system("pause");
    return 0;
}

POJ 1556

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int MAX=110;
#define max(a,b) (a)>(b)?(a):(b)
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int n,sum; //sum保存顶点的个数
struct Point
{   Point(){}
    Point(double c,double d):x(c),y(d){}
    double x,y;
};
struct Line
{   Line(){};
    Point a,b;
};
Line L[MAX];
Point P[MAX];
double multi(Point P1,Point P2,Point P0)
{   return (P1.x-P0.x)*(P2.y-P0.y)-(P2.x-P0.x)*(P1.y-P0.y);
}
bool Comp()
{
}
int main()
{   int m,sum=0;
    double u,v;
    n=0;
    scanf("%d",&m);
    for(int i=0;i<m;i++)
    {   scanf("%lf",&u);
        P[sum++]=Point(u,0);
        for(int j=0;j<4;j++)
        {   scanf("%lf",&v);
            P[sum++]=Point(u,v); //存储点的坐标
        }
        P[sum++]=Point(u,10);
    }
    for(int i=0;i<sum;i+=2)
    {   L[n].a=P[i];
        L[n++].b=P[i+1];
    }   
    for(int i=0;i<sum;i++)
        cout<<P[i].x<<" "<<P[i].y<<endl;
    for(int i=0;i<n;i++)
        printf("(%.lf,%.lf) (%.lf,%.lf)\n",L[i].a.x,L[i].a.y,L[i].b.x,L[i].b.y);       
    system("pause");
    return 0;
}

 

Tyvj  1301

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAX=2010;
#define Inf 10000000
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int num,n,m,Dist[MAX],visit[MAX],map[MAX][MAX];
int use[MAX][MAX];
int Prime(int p)
{   int sum=0,pos;
    CLR(visit,0);
    for(int i=1;i<=n;i++) 
        Dist[i]=map[p][i];
    visit[p]=1;
    for(int i=1;i<n;i++)
    {   int min=Inf;
        for(int j=1;j<=n;j++)
            if(!visit[j]&&min>Dist[j]) min=Dist[j],pos=j;
        if(use[][pos]!=-1) sum+=min;
        visit[pos]=1;
        for(int j=1;j<=n;j++)
            if(!visit[j]&&Dist[j]>map[pos][j])
            {   Dist[j]=map[pos][j];
                p=j;
            }       
    }    
    return sum;
}
int main()
{   int sum=0,p;
    num=0;
    for(int i=0;i<MAX;i++)
        fill(map[i],map[i]+MAX,Inf);
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {   int u,v,w;
        scanf("%d%d%d%d",&p,&u,&v,&w);
        if(p==1)
        {   sum+=w;
            use[u][v]=use[v][u]=-1; //标记(u,v)为必选路径
        }
        if(map[u][v]!=Inf)
        {   if(w>map[u][v]) w=map[u][v];
        }
        map[u][v]=map[v][u]=w;
    } 
    printf("%d\n",sum+Prime(1));  
    return 0;
}

 

 

tyvj 1032

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
int n,m;
struct Money
{   int a,b;
    bool operator<(const Money& M) const
    {   return a>M.a;
    }
};
int Count(int c,int d)
{   int sum=0;
    while(c<m)
    {   c+=d;
        sum++;
    }
    return sum;
}
int main()
{   int c,d,k,num;
    Money M[50];
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)
        scanf("%d%d",&M[i].a,&M[i].b);
    sort(M,M+n);
    int sum=0;
    for(int i=0;i<n;i++)
    {   if(M[i].a>=m) sum+=M[i].a;
        else
        {   int k=m/M[i].a;
            for(int j=n-1;j>i;j--)
            {   c=Count(k*M[i].a,M[j].a); //记录需要添加多少个M[j].a才能凑出大于m的数
                d=M[j].b/c;
                if(d>=M[i].b/k)
                {   int num=0;
                    num+=M[i].b/k;
                    M[i].b-=num*k;
                    M[j].b-=num*c;
                }
                sum+=num;
            }
        }
    }
    printf("%d\n",sum);
    system("pause");
    return 0;
}

/*
3 11
10 1
1 100
5 120
*/

 

hdu 1754

#include<iostream>
#include<cstdio>
using namespace std;
const int MAX=200010;
#define max(a,b) (a)>(b)?(a):(b)
int sum[MAX<<2];
void build(int l,int r,int root)
{   if(l==r)
    {   scanf("%d",&sum[root]);
        return;
    }
    int mid=(l+r)>>1;
    build(l,mid,root<<1);
    build(mid+1,r,(root<<1)+1);
    sum[root]=max(sum[root>>1],sum[(root>>1)+1]);
}
void update(int p,int add,int l,int r,int root)
{   if(l==r)
    {   sum[root]=add;
        return ;
    }
    int mid=(l+r)>>1;
    if(p<=mid) update(p,add,l,mid,root<<1);
    else update(p,add,mid+1,r,(root<<1)+1);
    sum[root]=max(sum[root>>1],sum[(root>>1)+1]);
}
int query(int ql,int qr,int l,int r,int root)
{   if(ql<=l&&r<=qr)
        return sum[root];
    int mid=(l+r)>>1;
    int res=0;
    if(ql<=mid) res=max(res,query(ql,qr,l,mid,root<<1));
    if(qr>mid) res=max(res,query(ql,qr,mid+1,r,(root<<1)+1));
    return res;
}
int main()
{   int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {   build(1,n,1);
        char op[8];
        int a,b;
        while(m--)
        {   scanf("%s",op);
            scanf("%d%d",&a,&b);
            if(op[0]=='U') update(a,b,1,n,1);
            else printf("%d\n",query(a,b,1,n,1));
        }
    }
    return 0;
}

tyvj 1348

/*#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAX=1010;
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int n,m,map[MAX][MAX],used[MAX],Link[MAX];
int use[MAX],Exp;
struct Good
{   int a,x,k;
    bool operator<(const Good& g) const
    {   return x>g.x;
    } 
}G[MAX];
int Prime(int n)
{   if(n==1||n==0) return 0;
    if(n==2) return 1;
    for(int i=2;i*i<=n;i++)
        if(n%i==0) return 0;
    return 1;   
}
int Path(int u)
{   for(int i=1;i<=n;i++)
        if(!used[i]&&map[u][i])
        {   used[i]=1;
            if(Link[i]<0||Path(Link[i]))
            {   Link[i]=u;
                return 1;
            }
        }
    return 0;   
}
int Max()
{   int sum=0;
    CLR(Link,-1);
    for(int i=1;i<=n;i++)
    {   CLR(used,0);
        if(Path(i)) sum++;
    }  
    return sum;
}
int main()
{   int u,v,num,flag;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&G[i].a);
    CLR(map,0);
   
    for(int i=1;i<=n;i++)
        if(Prime(G[i].a)) G[i].a=-1;       
    for(int i=1;i<=n;i++)
        scanf("%d%d",&G[i].x,&G[i].k);
        
    for(int i=1;i<=n;i++)
    {   if(G[i].a!=-1) continue;
        for(int j=i-G[i].k;j<=i+G[i].k;j++)
            if(G[j].a!=-1&&j>0&&j<=n) map[i][j]=1;          
    }
    Exp=0;
    cout<<Max()<<endl;
    for(int i=1;i<=n;i++)
        cout<<Link[i]<<" ";
    cout<<endl;   
    //sort(G+1,G+n+1);
    for(int i=1;i<=n;i++) 
        if(Link[i]!=-1) Exp+=G[i].x;
    cout<<Exp<<endl;
    system("pause");      
    return 0;
}
 */      
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAX=1010;
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int n,m,map[MAX][MAX],used[MAX],Link[MAX];
int a[MAX],x[MAX],k[MAX],use[MAX],Exp;
int Prime(int n)
{   if(n==1||n==0) return 0;
    if(n==2) return 1;
    for(int i=2;i*i<=n;i++)
        if(n%i==0) return 0;
    return 1;   
}
int Path(int u)
{   for(int i=1;i<=n;i++)
        if(!used[i]&&map[u][i])
        {   used[i]=1;
            if(Link[i]<0||Path(Link[i]))
            {   Link[i]=u;
                return 1;
            }
        }
    return 0;   
}
int Max()
{   int sum=0;
    CLR(Link,-1);
    for(int i=1;i<=n;i++)
    {   CLR(used,0);
        if(Path(i)) sum++;
    }  
    return sum;
}
int main()
{   int u,v,num,flag;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    CLR(map,0);
    for(int i=1;i<=n;i++)
        if(Prime(a[i])) a[i]=-1;       
    for(int i=1;i<=n;i++)
        scanf("%d%d",&x[i],&k[i]);
    for(int i=1;i<=n;i++)
    {   if(a[i]!=-1) continue;
        for(int j=i-k[i];j<=i+k[i];j++)
            if(a[j]!=-1&&j>0&&j<=n) map[i][j]=1;          
    }
    cout<<Max()<<endl;
    Exp=0;
    for(int i=1;i<=n;i++)
        if(Link[i]!=-1) Exp+=x[i];      
    cout<<Exp<<endl;
    system("pause");      
    return 0;
}
       

//西立面的电池铺设方案:
#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<numeric>
#include<windows.h>
using namespace std;
const int MAX=50;
const int N=5010;
const int MAXN=10010;
#define CLR(arr,val) memset(arr,val,sizeof(arr))
double Max,Rz[MAXN];
int h,x[25]={0,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3};
FILE *fp;

struct Nbq //逆变器的规格
{   double U,I,Min,Max,P,r,v;
    friend istream& operator>>(istream &cin,Nbq &N)
    {   cin>>N.U>>N.I>>N.Min>>N.Max>>N.P>>N.r>>N.v;
        return cin;
    }
}Nbq[MAX];

struct Dc //光伏电池的规格
{   double L,W,P,I,U,R,S,V;
    friend istream& operator>>(istream &cin,Dc &d)
    {   cin>>d.P>>d.L>>d.W>>d.U>>d.R>>d.V;
        d.S=d.L*d.W; //电池d的面积
        return cin;
    }
}Dc[MAX];

struct Plan //保存方案,[Start,End]表示逆变器的串联范围
{   int Start,a,b,End;
    double U;
}P[N];

struct BL //每一个逆变器的并联的最佳方案
{   double Count,Sp,Sv,pv; //最佳方案的面积,pv为性价比
    int x1,num1,x2,num2,e,posi,posj; //e作为编号
    bool operator<(const BL& B) const //按产生的功率从大到小排序
    {   return Sp/Sv>B.Sp/B.Sv;
    }
}Bl[N][N],T[N];

void mysort(int n,int k) //按照性价比排序
{  
}

int num=1,Path[MAX]; //记录每一种串联方案
double Total; //sum记录每一次面积的变化
void Find(int n) //找到与逆变器匹配的串联电路
{   for(int i=1;i<=24;i++)
        if(Dc[i].U<=Nbq[n].Max)
        {    double u=0,sum=0;
             while(sum<=Total&&u<=Nbq[n].Max)
             {   Path[i]++;
                 u+=Dc[i].U;
                 sum+=Dc[i].S;
                 if(u<Nbq[n].Min||u>Nbq[n].Max) continue;
                 P[num].a=i;
                 P[num].U=u;
                 P[num++].b=Path[i];
             }
        }
}

void Union(int n)
{   double psum,vsum,area;
    int k=1; 
    for(int i=P[n].Start;i<=P[n].End;i++)
    {  
        int A=P[i].a; //对应的型号
       
        psum=(Max*Dc[A].S*Dc[A].R*P[i].b)/1000000;
        vsum=P[i].b*Dc[A].V;
       
        for(int j=P[n].Start;j<=P[n].End;j++)
        {  
            int B=P[j].a; //对应的型号
            psum += (Max*Dc[B].S*Dc[B].R*P[j].b)/1000000;
            vsum += P[j].b*Dc[B].V;
            if(P[i].U<0.9*P[j].U||P[i].U>1.1*P[j].U) continue; //满足并联的条件

            //Bl[n][k].x1=A;
            //Bl[n][k].num1=P[i].b;
            //Bl[n][k].x2=B;
            //Bl[n][k].num2=P[j].b;
            Bl[n][k].posi=i; //记录位置
            Bl[n][k].posj=j;
            Bl[n][k++].pv=psum/vsum;
           
        }
    }
   
    for(int i=1;i<k;i++)
        for(int j=i+1;j<k;j++)
            if(Bl[n][i].pv<Bl[n][j].pv) swap(Bl[n][i],Bl[n][j]);
           
    for(int i=1;i<=3;i++)
    {  
        int A=P[Bl[n][i].posi].a; //posi位置的电池类型
        int B=P[Bl[n][i].posj].a; //posj位置的电池类型
        int C=P[Bl[n][i].posi].b; //posi位置的电池个数
        int D=P[Bl[n][i].posj].b; //posj位置的电池个数
        //cout<<"****************"<<Bl[n][i].posi<<" "<<Bl[n][i].posj<<endl;
       
        Bl[n][i].x1=A;
        Bl[n][i].x2=B;
        Bl[n][i].num1=C;
        Bl[n][i].num2=0;
      
        double sum=0;
        psum=(Max*Dc[A].S*Dc[A].R*C)/1000000;

        sum+=Dc[A].S*C;
       
        while(1)
        {  
            psum+=(Max*Dc[B].S*Dc[B].R*D)/1000000;
            sum+=Dc[B].S*D;            
            if(psum>Nbq[n].I*Nbq[n].U || sum>Total) break;
            Bl[n][i].num2+=D;

        }
       
    }
   
    /*
    cout<<"逆变器n:"<<endl;
    for(int i=1;i<=3;i++)
         printf("%d   %d   %d   %d\n",Bl[n][i].x1,Bl[n][i].num1,Bl[n][i].x2,Bl[n][i].num2);
    printf("\n");
    */
}

void West(int n) //南立面需要装的电池个数
{   int k=1;
    for(int i=1;i<=n;i++) //逆变器
    {  
        for(int j=1;j<=3;j++)
        {  
            int A=Bl[i][j].x1;
            int B=Bl[i][j].x2;
            int C=Bl[i][j].num1;
            int D=Bl[i][j].num2; 
           
            T[k].e=i;                                                                                                                                                  
            T[k].x1=A;
            T[k].num1=C;
            T[k].x2=B;
            T[k].num2=D;
            //T[k].Count=Dc[A].S*Bl[i][j].num1+Dc[C].S*Bl[i][j].num2; //每个组成逆变器的电路的所占的面积
            T[k].Sp=0; //计算光伏电池能够产生的总功率
            for(int t=1;t<=h;t++)
            {    if(x[A]!=3&&Rz[t]>=80)
                 {   if(x[A]==1&&Rz[t]<=200) Dc[A].R*=0.05;
                     T[k].Sp+=(Rz[t]*Dc[A].S*Dc[A].R*C)/1000000;
                 } 
                 if(x[A]==3&&Rz[t]>=30)
                 {   if(Rz[t]==200) Dc[A].R*=1.01;
                     T[k].Sp+=(Rz[t]*Dc[A].S*Dc[A].R*C)/1000000;
                 }
                 if(x[B]!=3&&Rz[t]>=30)
                 {   if(Rz[t]==200) Dc[B].R*=0.05;
                     T[k].Sp+=(Rz[t]*Dc[B].S*Dc[B].R*D)/1000000;
                 }
                 if(x[B]==3&&Rz[t]>=30)
                 {   if(Rz[t]==200) Dc[B].R*=1.01;
                     T[k].Sp+=(Rz[t]*Dc[B].S*Dc[B].R*D)/1000000;
                 }
            }    
            T[k++].Sv=Nbq[i].v+Dc[A].V*C+Dc[B].V*D; //总的成本
        }
        //printf("%.lf %.lf %.3lf\n",Bl[i].Sp,Bl[i].Sv,Bl[i].Sp/Bl[i].Sv);
    }
    
    sort(T+1,T+k); 
    for(int i=1;i<k;i++)
        printf("%d %d %d %d %d\n",T[i].e,T[i].x1,T[i].num1,T[i].x2,T[i].num2);
    //sort(T+1,T+n+1);
    /*for(int i=1;i<=n;i++)
        printf("第%d种逆变器的电池组合方案: %d %d %d %d\n",Bl[i].e,Bl[i].x1,Bl[i].num1,Bl[i].x2,Bl[i].num2);
    /*****************************
    for(int i=1;i<=n;i++)
        cout<<Bl[i].e<<endl;
    *****************************/
   
    //double sum=0;
    /*************************************
    cout<<"总面积:";
    printf("%.lf\n",Total);
    cout<<"输出每个最优方案的面积:"<<endl;
    for(int i=1;i<=n;i++)
         printf("%.lf\n",Bl[i].Count);
    cout<<"-----------------------"<<endl;
    *************************************/
   
    /*
    int j=1,y[MAX]; //y用来求适配器的个数,用来标记适配器有没有用过
    CLR(y,0);
    while(j<=n)
    {   if(sum+Bl[j].Count<=Total)
        {   sum+=Bl[j].Count;
            y[j]++;
        }    
        else j++;
    }
    int Ges=0;
    double SP=0,SV=0;
    cout<<"每种逆变器的个数及逆变器的电路组成的相关信息:"<<endl;
    for(int i=1;i<=n;i++)
         if(y[i])
         {    cout<<"逆变器型号:"<<Bl[i].e<<endl;
              cout<<"电路组成:"<<Bl[i].x1<<" "<<Bl[i].num1<<" ";
              if(Bl[i].x2) cout<<Bl[i].x2<<" "<<Bl[i].num2<<" "<<endl;
              printf("该电路的功率: %.3lf\n",Bl[i].Sp);
              SP+=Bl[i].Sp;
              printf("该电路的成本: %.3lf\n",Bl[i].Sv);
              SV+=Bl[i].Sv;
              Ges++;
         }
    SP/=1000; //化成kwh.
    printf("逆变器的个数:%d\n",Ges);
    printf("总的逆变器的功率:%.lf\n",SP);
    printf("产生的利润: %.2lf\n",SP*0.5);
    printf("总的逆变器的成本:%.lf\n",SV);     
    printf("利用率: %.6lf\n",sum/Total);
    printf("35年总的利润:%.2lf\n",10*SP+15*0.9*SP+10*0.8*SP);
    */
  
}
 
int main()
{   system("color 2e");
    int n,m;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>Nbq[i];
    cin>>m;   
    for(int i=1;i<=m;i++)
        cin>>Dc[i];
    Total=3800*7100; 
    if((fp=fopen("C:\\Documents and Settings\\Administrator\\桌面\\西立面逆变器的串联方案.txt","w"))==NULL) 
    {   printf("不能打开文件!!"); 
        exit(1); 
    }  
    P[1].Start=1;
    for(int i=1;i<=n;i++)
    {   CLR(Path,0);
        Find(i); //求出满足逆变器的额定电流电压的电池铺设方案:      
        fprintf(fp,"第%d种逆变器的纯串联方案:\n",i);
        fprintf(fp,"%lf %lf %lf\n",Nbq[i].I,Nbq[i].Min,Nbq[i].Max);
        P[i].End=num-1;
        fprintf(fp,"范围为:%d---%d\n",P[i].Start,P[i].End);
        for(int j=P[i].Start;j<=P[i].End;j++)
            fprintf(fp,"%d %d\n",P[j].a,P[j].b);
           
        P[i+1].Start=num;
    }
    fprintf(fp,"%d\n",num);
    fclose(fp); 
   
    cin>>h;
    for(int i=1;i<=h;i++)
        cin>>Rz[i];
    double Maxn=*max_element(Rz,Rz+MAX); //剔除最大的那个数
    Max=0;
    for(int i=1;i<=h;i++)
        if(Max<Rz[i]&&Max!=Maxn) Max=Rz[i];
    cout<<Max<<endl;
    
    for(int i=1;i<=n;i++)
    {   Union(i);   
        //cout<<Bl[i].x1<<" "<<Bl[i].num1<<" "<<Bl[i].x2<<" "<<Bl[i].num2<<endl;
    }
    
    /***************************************************
    for(int i=1;i<=m;i++)
        printf("%.6lf\n",(Max*Dc[i].S*Dc[i].R)/1000000);
    ***************************************************/
    West(n);
   
    system("pause");
    return 0;
}

Tyvj 1976

#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
using namespace std;
const int MAX=1500;
int move[4][2]={(1,0),(0,1),(-1,0),(0,-1)};
int tn,nextsx,nextsy,k,nowx,nowy,nextx,nexty,nowsx,nowsy,head,tail,tx,ty,n,m,i,j;
bool map[MAX][MAX];
int flag[MAX][MAX][2];
char temp;
bool can;
int queue[3000000][4];
int main()
{   while(scanf("%d%d",&n,&m)!=EOF)
    {   tn=n;
        can=false;
        memset(flag,0,sizeof(flag));
        while(tn>0)
        {   cin>>temp;
            if(temp=' ') continue;//！！！！！！
            for(j=1;j<=m;j++)
            {   if(temp=='.') map[n-tn+1][j]=true;
                if(temp=='#') map[n-tn+1][j]=false;
                if(temp=='S')
                {   map[n-tn+1][j]=true;
                    tx=n-tn+1;
                    ty=j;
                }
            }
            tn--;
        }
        queue[1][1]=tx;
        queue[1][2]=ty;
        queue[1][3]=0;
        queue[1][4]=0;
        flag[tx][ty][1]=0;
        flag[tx][ty][2]=0;
        head=0;
        tail=1;
        while(head<tail)
        {   head++;
            nowx=queue[head][1];
            nowy=queue[head][2];
            nowsx=queue[head][3];
            nowsy=queue[head][4];
            for(k=1;k<=4;k++)
            {   nextx=nowx+move[k][1];
                nexty=nowy+move[k][2];
                nextsx=nowsx;
                nextsy=nowsy;
                if(nextx<1)
                {   nextx=nextx+n;
                    nextsx--;
                }
                if(nexty<1)
                {   nexty=nexty+m;
                    nextsy--;
                }
                if(nextx>n)
                {   nextx=nextx-n;
                    nextsx++;
                }
                if(nexty>m)
                {   nexty=nexty-m;
                    nextsy++;
                }
                if((flag[nextx][nexty][1]!=nextsx) || (flag[nextx][nexty][2]!=nextsy) &&
                   (flag[nextx][nexty][1]!=-1) && (flag[nextx][nexty][2]!=-1))
                {   puts("Yes");
                    can=true;
                    break;
                }
                if(map[nextx][nexty] && (flag[nextx][nexty][1]!=nextsx) ||
                   (flag[nextx][nexty][2]!=nextsy))
                {   tail++;
                    queue[tail][1]=nextx;
                    queue[tail][2]=nexty;
                    queue[tail][3]=nextsx;
                    queue[tail][4]=nextsy;
                    flag[nextx][nexty][1]=nextsx;
                    flag[nextx][nexty][2]=nextsy;
                }

           }
           if(can) break;
         }
         if(!can) puts("No");
     }
     system("pause");
     return 0;
}

 

Tyvj 1047(乘积最大-区间动态规划)

#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
using namespace std;
const int MAX=50;
#define max(a,b) (a)>(b)?(a):(b)
#define CLR(arr,val) memset(arr,val,sizeof(arr))
string s;
long n,m,DP[MAX][MAX][10];
long num(int L,int R)
{   long sum=0;
    for(int i=L;i<=R;i++)
        sum=10*sum+(int)s[i]-'0';
    return sum;
}
int Max()
{   for(int k=0;k<=m;k++)
        for(int j=0;j<n;j++)
            for(int i=0;i<=j;i++)
                if(k<j-i+1)
                {   DP[i][j][k]=DP[i+1][j][k-1]*num(i,i);
                    for(int t=i;t<j;t++)
                        DP[i][j][k]=max(DP[i][j][k],DP[t+1][j][k-1]*num(i,t));
                }
    return DP[0][n-1][m];       
}
int main()
{   cin>>n>>m;
    cin.get();
    cin>>s;
    for(int i=0;i<n;i++)
    {   for(int j=i;j<n;j++)
        {   DP[i][j][0]=num(i,j);
            cout<<DP[i][j][0]<<" ";
        }
        cout<<endl;
    }    
    cout<<Max()<<endl;
    system("pause");
    return 0;
}