2019.10.21 csp-s模拟测试81 反思总结

T1：

把每一行状压，按行DP。设f_i,j,k，i表示第几行，j是当前行的1覆盖状态，k是当前行选择按钮的状态。转移的时候枚举j和k，再枚举下一层的按钮选择情况l。如果l和j可以全覆盖当前层则转移合法，根据下一层选择l状态的代价进行转移。预处理一行每一种选法i可以覆盖到的状态d_i，各行选择按钮状态i对应的代价dp_i，以及每一行的初始状态b_i。转移时下一层的覆盖情况就是k|d_l|b_i+1。初始化第一层是所有选法i对应的代价，即f_{1,d[i]|b[1],i}=dp_1,i。

整个DP过程的复杂度是O(3^m*2^m*n)。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=,maxn=<<N;
int n,maxx,ans,m,flag;
int s[N][N],a[N][N],dp[N][maxn],f[N][maxn][maxn],b[N],d[maxn];
int main()
{
    scanf("%d%d",&n,&m);
    maxx=<<m;
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            scanf("%1d",&s[i][j]);
            b[i]|=(s[i][j]<<(j-));
        }
    }
    for(int i=;i<maxx;i++){
        d[i]=(i|(i<<)|(i>>))&(maxx-);
    }
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            scanf("%d",&a[i][j]);
        }
        for(int j=;j<maxx;j++){
            for(int k=;k<=m;k++){
                if(j&(<<(k-))){
                    dp[i][j]+=a[i][k];
                }
            }
        }
    }
    memset(f,0x3f3f3f3f,sizeof(f));
    for(int j=;j<maxx;j++){
        f[][d[j]|b[]][j]=min(f[][d[j]|b[]][j],dp[][j]);
    }
    for(int i=;i<n;i++){
        for(int j=;j<maxx;j++){
            if((j&b[i])!=b[i])continue;
            for(int k=j;k>=;k=(k-)&j){
                if((d[k]&j)!=d[k]&&k)continue;
                for(int l=;l<maxx;l++){
                    if((j|l)==(maxx-)){
                        f[i+][d[l]|k|b[i+]][l]=min(f[i+][d[l]|k|b[i+]][l],f[i][j][k]+dp[i+][l]);
                    }
                }
                if(!k)break;
            }
        }
    }
    ans=0x3f3f3f3f;
    for(int i=;i<maxx;i++)ans=min(ans,f[n][maxx-][i]);
    printf("%d\n",ans);
    return ;
}

处理b的时候反着处理了整张图，并且初始化第一行的时候出了锅没考虑b数组，于是写了一下午。

T2：

第一问比较容易。把求方案数的过程看成一个往序列里添加元素的过程。将原序列按第一关键字val从大到小，第二关键字key从小到大排序。val从大到小保证了后添加的元素无论放在哪都不会影响前面放进来的元素，并且已经存在的每一个元素都会对当前元素的key值产生贡献。所以只用考虑当前要放的元素本身的限制，考虑怎么求这一次操作的方案数，即新加入的元素能放在哪些地方。如果序列里的元素个数小于key_i，那么显然最多只有i个位置可以放（1->i）。如果序列里的元素多于等于key_i个，那么也只有前key_i个位置可以放，这样才不会超出key的限制。特别的状况是存在相同的val，这就是前面key作为第二关键字从小到大排序的原因。相同val的key从小到大，保证对于后加入的元素，先加入的val相同的元素所在的位置也可以放当前的元素。先加入的元素为后加入的元素创造了新的位置，它所在的地方后加入的元素一定可以放到。于是对于相同的val累计一个num，num从已有的第二个相同val开始累计，ans=(ans*min(i,key_i+num))%mod。

第二问愣是没想出来，也没看明白题解里平衡树的做法。好像是根据第一问的过程，每次插入一个元素的时候，贪心地放在能放的最大位置之前的第一个字典序比它大的元素前面。然后就不会写了。

题解的第二种做法是利用线段树，也是贪心地构造一个序列。一开始所有元素都是未加入元素。如果已经加入的元素的个数小于手中所有元素的key值-1，那么随便把哪个元素扔进序列都合法。根据题目要求，显然选择未加入的元素中字典序最小的。如果未加入的元素中存在key被卡在界限上，那么要么把它丢进序列，要么在val小于等于它的元素中选择更优的丢进序列。于是可以想到把原序列按val第一关键字从小到大key第二关键字从小到大排序，用线段树维护序列。选择要加入序列的元素就是在线段树的一段区间上选择key最小的元素。每次将一个元素扔进序列后，把线段树上这个元素的所有信息都变成inf，并且把所有未加入序列且val比它小的元素的key值-1，即线段树上的区间减。这里的key其实要记两次，一个记作用来当作限制，进行区间减操作。一个始终不变，用来在区间查询的时候作为可能答案进行比较。更新区间最小限制值以及key值的时候若出现值相同的元素，更新为在线段树上更靠前的，也就是val更小的。一个是构造的序列要求第二关键字val也是从小到大。另一个是若有多个key值同时等于1，要用val最小的来限制答案。否则根据更大的val选择出来的答案可能不满足val小的key的限制。

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int n,mod=1e9+,num;
const int N=*1e5+,inf=;
long long ans;
struct node{
    int key,val;
}a[N];
struct tree{
    int l,r,dic,dici,val,vali,tag,top,topi;
}b[N*];
bool cmp(node a,node b){
    if(a.val>b.val)return true;
    else if(a.val==b.val){
        if(a.key<b.key)return true;
        else return false;
    }
    else return false;
}
bool cmp1(node a,node b){
    if(a.val<b.val)return true;
    else if(a.val==b.val){
        if(a.key<b.key)return true;
        else return false;
    }
    else return false;
}
void pushup(int p){
    if(b[p*].dic<b[p*+].dic){
        b[p].dic=b[p*].dic;
        b[p].dici=b[p*].dici;
    }
    else if(b[p*].dic==b[p*+].dic){
        b[p].dic=b[p*].dic;
        if(b[p*].dici<b[p*+].dici){
            b[p].dici=b[p*].dici;
        }
        else b[p].dici=b[p*+].dici;
    }
    else{
        b[p].dic=b[p*+].dic;
        b[p].dici=b[p*+].dici;
    }
    if(b[p*].val<b[p*+].val){
        b[p].val=b[p*].val;
        b[p].vali=b[p*].vali;
    }
    else if(b[p*].val==b[p*+].val){
        b[p].val=b[p*].val;
        if(a[b[p*].vali].key<a[b[p*+].vali].key){
            b[p].vali=b[p*].vali;
        }
        else{
            b[p].vali=b[p*+].vali;
        }
    }
    else{
        b[p].val=b[p*+].val;
        b[p].vali=b[p*+].vali;
    }
    if(b[p*].top<b[p*+].top){
        b[p].top=b[p*].top;
        b[p].topi=b[p*].topi;
    }
    else if(b[p*].top==b[p*+].top){
        b[p].top=b[p*].top;
        if(b[p*].topi<b[p*+].topi){
            b[p].topi=b[p*].topi;
        }
        else b[p].topi=b[p*+].topi;
    }
    else{
        b[p].top=b[p*+].top;
        b[p].topi=b[p*+].topi;
    }
}
void pushdown(int p){
    if(b[p].tag){
        b[p*].tag+=b[p].tag;
        b[p*].dic-=b[p].tag;
        b[p*+].tag+=b[p].tag;
        b[p*+].dic-=b[p].tag;
        b[p].tag=;
    }
}
void build(int p,int l,int r){
    b[p].l=l,b[p].r=r;
    if(l==r){
        b[p].dic=a[l].key,b[p].dici=l;
        b[p].val=a[l].val,b[p].vali=l;
        b[p].top=a[l].key,b[p].topi=l;
        return;
    }
    int mid=(l+r)/;
    build(p*,l,mid);
    build(p*+,mid+,r);
    pushup(p);
}
void change(int p,int l,int r,int y){
    if(l<=b[p].l&&b[p].r<=r){
        b[p].dic=b[p].val=b[p].top=y;
        a[b[p].l].key=y;
        return;
    }
    pushdown(p);
    int mid=(b[p].l+b[p].r)/;
    if(l<=mid)change(p*,l,r,y);
    if(r>mid)change(p*+,l,r,y);
    pushup(p);
}
void change1(int p,int l,int r,int y){
    if(l<=b[p].l&&b[p].r<=r){
        b[p].dic--;
        b[p].tag++;
        return;
    }
    pushdown(p);
    int mid=(b[p].l+b[p].r)/;
    if(l<=mid)change1(p*,l,r,y);
    if(r>mid)change1(p*+,l,r,y);
    pushup(p);
}
int ask(int p,int l,int r){
    if(l<=b[p].l&&b[p].r<=r){
        return b[p].topi;
    }
    pushdown(p);
    int mid=(b[p].l+b[p].r)/;
    int x=;
    a[x].key=a[x].val=inf;
    if(l<=mid){
        int y=ask(p*,l,r);
        if(a[y].key<a[x].key)x=y;
        else if(a[y].key==a[x].key){
            if(a[y].val<a[x].val)x=y;
        }
    }
    if(r>mid){
        int y=ask(p*+,l,r);
        if(a[y].key<a[x].key)x=y;
        else if(a[y].key==a[x].key){
            if(a[y].val<a[x].val)x=y;
        }
    }
    pushup(p);
    return x;
}
int main()
{
    scanf("%d",&n);
    for(int i=;i<=n;i++){
        scanf("%d%d",&a[i].key,&a[i].val);
    }
    sort(a+,a+n+,cmp);
    ans=;
    for(int i=;i<=n;i++){
        if(i>&&a[i].val==a[i-].val)num++;
        else num=;
        ans=ans*min(i,a[i].key+num)%mod;
    }
    printf("%lld\n",ans);
    sort(a+,a+n+,cmp1);
    build(,,n);
    for(int i=,x;i<=n;i++){
        if(b[].dic==)x=ask(,,b[].dici);
        else x=b[].topi;
        printf("%d %d\n",a[x].key,a[x].val);
        if(x>)change1(,,x-,-);
        change(,x,x,inf);
    }
    return ;
}

第一问没想多长时间，第二问也没改多长时间（至少比我作为全场倒数改出来的T1要强），但是考场上就是没想出第二问怎么写。按理说贪心的思路也不是很难想…

T3：

不会，没写，咕着。

关于像在长郡考试那次一样把自己的电脑卡死机两次还不得不关机一次这件事情我还能说什么呢我给自己找扇窗户吧

关于T1不好好打暴力搜索非要搞玄学状压搜索这件事情我都不用给自己找扇窗户了就地蒸发吧

菜 墨雨笙 菜