Codeforces Round #197 (Div. 2) (C~E)

于 2013-08-27 12:09:19 发布
阅读量803 收藏
点赞数
分类专栏： Codeforces 文章标签： codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gzh1992n/article/details/10382323
版权

C:

贪心。每次选一个最小的满足条件的砝码即可，这样能留给后面更多的选择余地。

但是光是这样还有一点小问题。当时就因为只是这样随手一贪，导致最后挂了。。。

我们应该还要先枚举第一个砝码放谁，再开始贪心。

例如：

有砝码1，2，3，需要放4块。

单纯贪心的话，会这样选择：1，2，3，*。（*代表无法选择，终止了）

对于左边的天平有1+3=4 kg，右边有3 kg。

此时选砝码1，2，不能大于4，非法。选3，和前面重复，非法。

但其实我们可以2，3，2，3的放，是有解的。

所以要枚举第一块砝码，然后贪心。


code：

#include <algorithm>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <math.h>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <set>
#include <map>
using namespace std;

/*-------------------------Template----*/
#define N  50010
#define E  100010
#define ll long long
#define CB(x) ((x)*(x)*(x))
#define SQ(x)     ((x)*(x))
#define ALL(x)     x.begin(),x.end()
#define CLR(x,a) memset(x,a,sizeof(x))
#define maxAry(a,n) max_element(a,a+(n))
#define minAry(a,n) min_element(a,a+(n))
typedef pair<int,int> PI;
const int INF=0x3fffffff;
const int PRIME =999983;
const int MOD   =1000000007;
const int MULTI =1000000007;
const double EPS=1e-9;
/*----------------------end Template----*/

int n;
char s[16];
vector<int> d,ans;
ll w[2];

bool cal(int x)
{
    int no=x;
    w[0]=d[x];
    w[1]=0;
    ans.clear();
    ans.push_back(d[x]);
    for(int i=2;i<=n;i++){
        bool tag=true;
        for(int j=0;j<d.size();j++){
            if(j!=no && w[i%2]<w[(i+1)%2]+d[j]){
                w[(i+1)%2]+=d[j];
                ans.push_back(d[j]);
                no=j;
                tag=false;
                break;
            }
        }
        if(tag) return false;
    }
    puts("YES");
    for(int i=0;i<ans.size();i++)
        printf("%s%d", i?" ":"",ans[i]);
    return true;
}

int main()
{
    scanf("%s",s);
    for(int i=0;i<10;i++){
        if(s[i]=='1'){
            d.push_back(i+1);
        }
    }
    sort(ALL(d));
    scanf("%d",&n);
    for(int i=0;i<d.size();i++) if(cal(i)) return 0;
    puts("NO");
    return 0;
}



D:

线段树。

把相邻两个数合并，就相当于线段树把左子树和右子树合并。

每个节点存的是这段区间合成一个数后的值。然后再标记下该节点的两个子节点应该做什么运算。

至于每次修改值，就是单点更新了。

可以单独考虑二进制每一位。（写完发现根本不用单独考虑二进制位，直接算就好了，拙计了。。。）


code：

#include <algorithm>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <math.h>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <set>
#include <map>
using namespace std;

/*-------------------------Template----*/
#define N  131100
#define E  100010
#define ll long long
#define CB(x) ((x)*(x)*(x))
#define SQ(x)     ((x)*(x))
#define ALL(x)     x.begin(),x.end()
#define CLR(x,a) memset(x,a,sizeof(x))
#define maxAry(a,n) max_element(a,a+(n))
#define minAry(a,n) min_element(a,a+(n))
typedef pair<int,int> PI;
const int INF=0x3fffffff;
const int PRIME =999983;
const int MOD   =1000000007;
const int MULTI =1000000007;
const double EPS=1e-9;
/*----------------------end Template----*/

class segTree{
#define lson rt<<1
#define rson rt<<1|1
#define rtl seg[rt].l
#define rtr seg[rt].r
private:
    struct segment{
        int l,r,num[30],t;
    }seg[N<<2];
public:
    void pushup(int rt)
    {
        seg[rt].t=seg[lson].t^1;
        for(int i=0;i<30;i++){
            if(seg[rt].t)
                seg[rt].num[i]=seg[lson].num[i] | seg[rson].num[i];
            else
                seg[rt].num[i]=seg[lson].num[i] ^ seg[rson].num[i];
        }
    }
    void update(int x,int pos,int rt)
    {
        if(rtl==rtr){
            CLR(seg[rt].num,0);
            for(int i=0;i<30;i++)
                if((1<<i)&x)
                    seg[rt].num[i]=1;
            return ;
        }
        int mid=(rtl+rtr)>>1;
        if(pos<=mid) update(x,pos,lson);
        else update(x,pos,rson);
        pushup(rt);
    }
    int query()
    {
        int x=0;
        for(int i=0;i<30;i++) if(seg[1].num[i]){
            x+=1<<i;
        }
        return x;
    }
    void build(int l,int r,int rt)
    {
        rtl=l,rtr=r;
        if(l==r){
            int x;
            scanf("%d",&x);
            CLR(seg[rt].num,0);
            for(int i=0;i<30;i++)
                if((1<<i)&x)
                    seg[rt].num[i]=1;
            seg[rt].t=0;
            return ;
        }
        int mid=(l+r)>>1;
        build(l,mid,lson);
        build(mid+1,r,rson);
        pushup(rt);
    }

}T;


int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    n=pow(2.0,n);
    T.build(1,n,1);
    int p,x;
    while(m--){
        scanf("%d%d",&p,&x);
        T.update(x,p,1);
        printf("%d\n", T.query());
    }
    return 0;
}


E:

每次找到最左（右）的错排位置，把相应的该放这个位置的数翻转回到这个位置。

若干次后必然能回到原始序列。但是题目要求最多操作3次，所以需要dfs搜出一个小于等于3次的答案。

至于复杂度，这样爆搜为什么不会TLE。

我拙计的分析下：

在原始序列上最多翻转3，能产生最左（右）的错排位置不多，假设有x个。

所以dfs的复杂度最坏O(nx^2^3)。

x显然不大，感觉是这样。。。

而且因为必然有3次以内的解，随便翻几次应该很多都在正确的位置了。

其实关键还是最多3次的限制降低了复杂度，大于3次的都剪掉了，小于等于3次的也不多。


以上分析，最好别看，因为完全是我自己猜的。。。

如果大神有严谨的分析，还望在楼下告诉弱菜。


code:

#include <algorithm>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <math.h>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <set>
#include <map>
using namespace std;

/*-------------------------Template----*/
#define N  1024
#define E  100010
#define ll long long
#define CB(x) ((x)*(x)*(x))
#define SQ(x)     ((x)*(x))
#define ALL(x)     x.begin(),x.end()
#define CLR(x,a) memset(x,a,sizeof(x))
#define maxAry(a,n) max_element(a,a+(n))
#define minAry(a,n) min_element(a,a+(n))
typedef pair<int,int> PI;
const int INF=0x3fffffff;
const int PRIME =999983;
const int MOD   =1000000007;
const int MULTI =1000000007;
const double EPS=1e-9;
/*----------------------end Template----*/

int n,a[N];
vector<PI > ans;
bool tag=false;

int getL()
{
    for(int i=1;i<=n;i++) if(a[i]!=i) return i;
    return 0;
}

int getR()
{
    for(int i=n;i>=1;i--) if(a[i]!=i) return i;
    return 0;
}

int getPos(int x)
{
    for(int i=1;i<=n;i++) if(a[i]==x) return i;
}

void output()
{
    printf("%d\n", ans.size());
    for(int i=ans.size()-1;i>=0;i--){
        printf("%d %d\n", ans[i].first,ans[i].second);
    }
}

void dfs(int comd)
{
    int l=getL();
    if(l==0){ 
        output(); 
        tag=true;
        return;
    }
    if(comd==3) return ;
    int r=getPos(l);
    reverse(a+l,a+r+1);
    ans.push_back(make_pair(l,r));
    dfs(comd+1);
    reverse(a+l,a+r+1);
    ans.pop_back();
    if(tag) return ;
    r=getR();
    l=getPos(r);
    reverse(a+l,a+r+1);
    ans.push_back(make_pair(l,r));
    dfs(comd+1);
    reverse(a+l,a+r+1);
    ans.pop_back();
}

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



ZephyrGuo
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值