10月集训test17&&test18

1.昨天心情不好并不想写总结。
2.今天心情依旧不好。
3.负负得正不如今天一起写了。
4.哦还有第三题都写不来正解打了暴力，今天第一题也好难，比第二题第三题都要难。
5.0+0+20 以及 我没有交【还没有打完啊。。。】
6.今天的第一题只有暴力。
今天的风儿依旧是如此喧嚣。

1.arrange

贪心就好了，想多了总是要出些问题。排序不要拘泥于以起点为关键字排序，排序终点或者是长度也是可以的。哦还有动态规划依旧可做。
贪心的时候每次只要能取就取，由于排过序，怎样都是最优的。

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;

struct node
{
    int s,t;
}a[100010];
int n,ans,bb;
int b[100010];
char s1[7],s2[7];

inline int read()
{
    int i=0;char c;
    for(c=getchar();c<'0'||c>'9';c=getchar());
    for(;c>='0'&&c<='9';c=getchar())
        i=(i<<1)+(i<<3)+c-'0';
    return i;
}

inline bool comp(const node &x,const node &y)
{
    return x.t<y.t;
}

int main()
{
    //freopen("arrange.in","r",stdin);
    //freopen("arrange.out","w",stdout);

    n=read();
    for(int i=1;i<=n;i++)
    {
        cin>>s1>>s2;
        a[i].s=((s1[0]-'0')*10+(s1[1]-'0'))*60+(s1[3]-'0')*10+s1[4]-'0';
        a[i].t=((s2[0]-'0')*10+(s2[1]-'0'))*60+(s2[3]-'0')*10+s2[4]-'0';
    }
    sort(a+1,a+n+1,comp);
    ans=0;bb=0;
    for(int i=1;i<=n;i++)
        if(a[i].s>=bb)
            bb=a[i].t,ans++;
    cout<<ans<<endl;    
    return 0;
}

2.seq

讲真这个文件名太有迷惑性了，差一点就打错了。（虽然结果没什么不一样）
正解还是代码量挺长的，二分答案加单调队列。
二分枚举平均数，判断是否可行。对于原来的数组求一个前缀和sum，，找到满足sum[r]-sum[l]>=x*(r-l)并且L<=r-l<=R。
那么我们将a[i]全部减去x，重新求sum。枚举r，遍历可行的l，求一段长度固定的区间中的最小值，移动区间加入下一个位置或去掉上一个位置，扫一遍判断。
但是，为什么不用暴力呢，呵呵。

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;

int n,l,r;
int a[20010];
long long s[20010],aa;
double ans=0;

inline int read()
{
    int i=0;char c;
    for(c=getchar();c<'0'||c>'9';c=getchar());
    for(;c>='0'&&c<='9';c=getchar())
        i=(i<<1)+(i<<3)+c-'0';
    return i;
}

int main()
{
    //freopen("seq.in","r",stdin);
    //freopen("seq.out","w",stdout);

    n=read(),l=read(),r=read();
    for(register int i=1;i<=n;i++)
        a[i]=read(),s[i]=(long long)s[i-1]+a[i];
    for(register int i=l;i<=r;i++)
    {   
        for(register int j=i;j<=n;j++)
            aa=max(aa,s[j]-s[j-i]);
        if((1.0*aa/i)>ans) ans=1.0*aa/i;
    }
    printf("%0.4f\n",ans);
    return 0;
}

暴力无罪数据水。

3.回文子串

动态规划。
f[a][b][c][d]表示s的a~b和t的c~d能否按顺序组成一个回文串。若答案是一个字符串的字串，特判一下。又由于是按顺序，所以字符串的首位必为s[a]或是t[c]，最末字符只可能是s[b]或t[d]。注意边界的特殊处理。
借用一下jly的代码 @assmel

#include<bits/stdc++.h>
using namespace std;
int n,m,ans,dp[55][55][55][55];
char s[55],t[55];
bool vis[55][55][55][55];
struct pos{
    int a,b,c,d;
    pos(int a,int b,int c,int d):a(a),b(b),c(c),d(d){
    }
};
queue< pos > q;
int main(){
    //freopen("palin.in","r",stdin);
    scanf("%s",s+1);n=strlen(s+1);
    scanf("%s",t+1);m=strlen(t+1);
    queue<pos> q;
    for(int i=1;i<=n;i++)
      for(int j=1;j<=m;j++)
        for(int k=n;k>=i-1;k--) //这里 -1 是因为有可能一个串根本没有用 
          for(int l=m;l>=j-1;l--)  //同上 
            q.push(pos(i,j,k,l)),vis[i][j][k][l]=true;
    while(!q.empty()){
        pos tmp=q.front();q.pop();
        int a=tmp.a,b=tmp.b;
        int c=tmp.c,d=tmp.d;
        vis[a][b][c][d]=false;
        int x=dp[a][b][c][d];
        if(a<c){
            if(s[a]==s[c] && x+2>dp[a+1][b][c-1][d]){
                dp[a+1][b][c-1][d]=x+2;
                if(!vis[a+1][b][c-1][d]){
                  vis[a+1][b][c-1][d]=true;
                  q.push(pos(a+1,b,c-1,d));
                }
            }
        }
        if(b<d){
            if(t[b]==t[d] && x+2>dp[a][b+1][c][d-1]){
                dp[a][b+1][c][d-1]=x+2;
                if(!vis[a][b+1][c][d-1]){
                  vis[a][b+1][c][d-1]=true;
                  q.push(pos(a,b+1,c,d-1));
                }
            }
        }
        if(a<=c && b<=d){
            if(s[a]==t[d] && x+2>dp[a+1][b][c][d-1]){
                dp[a+1][b][c][d-1]=x+2;
                if(!vis[a+1][b][c][d-1]){
                  vis[a+1][b][c][d-1]=true;
                  q.push(pos(a+1,b,c,d-1));
                }
            }
            if(t[b]==s[c] && x+2>dp[a][b+1][c-1][d]){
                dp[a][b+1][c-1][d]=x+2;
                if(!vis[a][b+1][c-1][d]){
                  vis[a][b+1][c-1][d]=true;
                  q.push(pos(a,b+1,c-1,d));
                }
            }
        }
    }
    for(int i=0;i<=n+1;i++)
      for(int j=0;j<=m+1;j++)
        for(int k=n+1;k>=0;k--)
          for(int l=m+1;l>=0;l--){
              int x=dp[i][j][k][l];
              if(i==k && l<j) ans=max(ans,x+1);
              if(j==l && k<i) ans=max(ans,x+1);
              if(i>k && j>l)  ans=max(ans,x);
          }
    cout<<ans;
}

1.interval

先特判x或是y没有出现在序列a中的情况，然后维护一个前缀和，如果等于x就加一，等于y就减一，看每一次有多少个与之前相同，加进答案里。
但是不等于x或是y的部分这个值是不变的，所以先找出x和y的所有位置，排序后再从前往后扫一遍。

//30%暴力
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;

int n,q,x,y,ans,ans1,ans2;
int a[8010];

inline int read()
{
    int i=0;char c;
    for(c=getchar();c<'0'||c>'9';c=getchar());
    for(;c>='0'&&c<='9';c=getchar())
        i=(i<<1)+(i<<3)+c-'0';
    return i;
}

int main()
{
    //freopen("interval.in","r",stdin);
    //freopen("interval.out","w",stdout); 

    n=read(),q=read();
    for(int i=1;i<=n;i++)
        a[i]=read();
    while(q--)
    {
        x=read(),y=read();
        ans=0;
        for(int i=1;i<=n;i++)
        {
            ans1=0,ans2=0;
            for(int j=i;j<=n;j++)
            {
                if(a[j]==x) ans1++;
                if(a[j]==y) ans2++;
                if(ans1==ans2) ans++;
            }   
        }
        cout<<ans<<endl;    
    }
    return 0;
}

2.premu

先作差得到逆序数，根据最后一个逆序数确定最后一个数，然后将其标记，前一个数为剩下的数的第逆序数个。
直接暴力只能过一半的点，用二分+树状数组优化，或者用线段树优化。

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;

int n,m,k,aa;
int p[100010],a[100010];
int tree[400010];

inline int read()
{
    int i=0;char c;
    for(c=getchar();c<'0'||c>'9';c=getchar());
    for(;c>='0'&&c<='9';c=getchar())
        i=(i<<1)+(i<<3)+c-'0';
    return i;
}

inline void build(int num,int l,int r)
{
    if(l==r)
    {
        tree[num]=1;
        return;
    }
    int mid=(l+r)/2;
    build(num*2,l,mid);
    build(num*2+1,mid+1,r);
    tree[num]=tree[num*2+1]+tree[num*2];
}

inline int query(int num,int l,int r,int x)
{
    if(l==r)
    {
        tree[num]=0;
        return l;
    }
    int mid=(l+r)/2,ret;
    if(x<=tree[num*2])
        ret=query(num*2,l,mid,x);
    else
        ret=query(num*2+1,mid+1,r,x-tree[num*2]);
    tree[num]=tree[num*2]+tree[num*2+1];
    return ret;
}

int main()
{
    //freopen("premu.in","r",stdin);
    //freopen("premu.out","w",stdout);

    n=read();
    for(int i=1;i<=n;i++)
        p[i]=read();
    for(int i=n;i>=1;i--)
        p[i]-=p[i-1];
    for(int i=1;i<=n;i++)
        p[i]=i-p[i];
    build(1,1,n);
    for(int i=n;i>=1;i--)
        a[i]=query(1,1,n,p[i]);
    for(int i=1;i<=n;i++)
        cout<<a[i]<<" ";
    return 0;   
}

3.side

话说这道题考试的时候真心没有认真的做，第一题想题就花了不少时间，第二题debug还没完考试就快结束了，草草扫了几眼。。。。。
其实就是分治，分而治之。
先将询问离线，假设当前处理分治区间[l,r]，设mid=(l+r)/2，处理询问区间跨过了mid的询问，可以用DP得到lef[i][x][y]表示从x出发，处理了从i到mid的边之后到达y的最小代价。同理，rif[i][x][y]表示从x出发，处理了从mid+1到i的边之后到达y的最小代价。查询的时候只需要枚举中间经过的点。
具体分析及代码我们来仰望dalao~
http://blog.csdn.net/scar_lyw/article/details/78439753

以上。
来自2017.11.3

——我认为return 0，是一个时代的终结。