CF hello 2018(A~E)

点此打开

A

代码示例

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
    ios::sync_with_stdio(false);
    ll m,n;
    cin>>n>>m;
    if(n>=30){
        cout<<m<<endl;
    }
    else{
        cout<<m%(ll)pow(2,n)<<endl;
    }
    return 0;
}

B

思路

统计叶子节点，判断每个非叶子节点是否满足条件（有>=3个子节点是叶子）

代码示例

#include<bits/stdc++.h>
using namespace std;

int flag;

set<int> xiang;//叶子节点的编号

struct Edge{
    int from,to,dist;
    Edge(int u,int v,int w):from(u),to(v),dist(w){
    }
};

const int maxn=10000;//结点数

int root;//根节点

vector<Edge> edges;//边的具体信息

vector<int> G[maxn];//边的编号

void addEdge(int u,int v,int w){
    edges.push_back(Edge(u,v,w));
    edges.push_back(Edge(v,u,w));
    int size=edges.size();
    G[u].push_back(size-2);//从u起点的边在edges中的下标
    G[v].push_back(size-1);//从v起点的边在edges中的下标
}

void dfs(int n,int fa)
{
    if(G[n].size()==1&&n!=1){//只有一条边，并且不是根节点
        xiang.insert(n);
        return ;
    }
    for(int i=0;i<G[n].size();++i){
        Edge e=edges[G[n][i]];
        if(e.to!=fa){
            dfs(e.to,n);
        }
    }
}

void dfs1(int n,int fa)
{
    //cout<<"现在节点为"<<n<<' '<<"父亲为"<<fa<<endl;
    if(G[n].size()==1&&n!=1){
        return ;
    }
    int num=0;
    for(int i=0;i<G[n].size();++i){
        Edge e=edges[G[n][i]];
        if(e.to!=fa){
            if(xiang.count(e.to)) num++;
            else dfs1(e.to,n);
        }
    }
    if(num<3){
        flag=0;
        return ;
    }
}

int main()
{
    flag=1;//默认是杉树
    ios::sync_with_stdio(false);
    root=1;//根节点为1
    int n,temp;//结点数
    cin>>n;
    for(int i=2;i<=n;++i){
        cin>>temp;
        addEdge(temp,i,1);//距离这题用不到，置为1
    }
    dfs(root,0);//统计叶子结点

    /*输出叶子节点
    for(set<int>::iterator it=xiang.begin();it!=xiang.end();++it){
        cout<<*it<<' ';
    }
    */
    dfs1(root,0);
    if(flag) cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
    return 0;
}

C

思路

贪心，具体见注释

代码示例（WA）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const double eps=1e-6;

struct point{
    ll vol;//容量
    ll pri;//价格
    double ahu;//单价
}po[40];

cmp(point a,point b){
    if(fabs(a.ahu-b.ahu)<eps) return a.vol<b.vol;
    else return a.ahu<b.ahu;
}


int main()
{
    ios::sync_with_stdio(false);
    //cout<<(ll)pow(2,29)<<endl;
    ll L;//L为需要的量
    //现在提供的升数均为2的次幂
    int n;//n种规格
    cin>>n>>L;
    ll ans=0;
    for(int i=1;i<=n;++i){
        po[i].vol=(ll)pow(2,i-1);
        cin>>po[i].pri;
        po[i].ahu=po[i].pri*1.0/po[i].vol;
    }

    /*
    for(int i=1;i<=n;++i){
        cout<<"第"<<i<<"种瓶子："<<"容量为"<<po[i].vol<<"   价格为"<<po[i].pri<<"   单价为"<<po[i].ahu<<endl;
    }
    cout<<endl<<endl;
    */
    sort(po+1,po+n+1,cmp);
    /*
    for(int i=1;i<=n;++i){
        cout<<"第"<<i<<"种瓶子："<<"容量为"<<po[i].vol<<"   价格为"<<po[i].pri<<"   单价为"<<po[i].ahu<<endl;
    }
    */

    while(1)
    {
        ans+=L/po[1].vol*po[1].pri;//花费的钱
        L=L-L/po[1].vol*po[1].vol;//需要买的瓶数
        if(L<=0) break;
        //现在单价最小的被我买完了，说明我剩下的升数是小于这一瓶的升数的
        //下面我修改这瓶的单价重新排序
        po[1].vol=L;
        po[1].ahu=po[1].pri*1.0/po[1].vol;
        sort(po+1,po+n+1,cmp);
    }
    cout<<ans<<endl;
    return 0;
}

代码示例（AC）

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

int main()
{
    int n,L;
    scanf("%d %d",&n,&L);
    vector<int> c(n);
    for(int i=0;i<n;i++){
        scanf("%d",&c[i]);
    }

    for(int i=0;i<n-1;i++){//第一步处理,容量加倍但价格加了不止两倍的进行“降价”
        c[i+1]=min(c[i+1],2*c[i]);
    }

    long long ans=(long long) 5e18;//一个较大数
    long long sum=0;


  //从大的开始选 对当前品种最后一个容量（选了会>=L的）做个选择：选还是不选，求出min。选了则买够了，即sum+(L>0)*c[i]；没选则继续循环，在当前sum的基础上，还剩下L-=need<<i待够，然后做同样的事情。     
      //注意：由于瓶子的容量是1,2,4,8...，所以可以保证恰好组成第一次的那个L-=need<<i。所以该题本质就是从一个瓶（这个瓶肯定相比较来说a（i+1）<2*ai ，即更实惠）买够容量，剩下的都不看了。代码所做的就是枚举这个"lucky bottle"
    for(int i=n-1;i>=0;i--){
        int need=L/(1<<i);
        sum+=(long long)need*c[i];
        L-=need<<i;
        ans=min(ans,sum+(L>0)*c[i]);
    }
    cout<<ans<<endl;
    return 0;
}

D

思路

贪心+优先队列维护

先对所有的exam按照时间进行排序，时间小的优先。

优先队列 维护数据，limit小的在前面 ;limit一样的 t大的在前面

大致步骤：

①对于每个exam，优先选择时间小的，其时间大于剩余总时间了，break；

②没break,则其可不可选要看其limit是否大于当前已做的ans ，若大于进优先队列,ans++；

③每一次ans改变后，检查优先队列top是否满足限制了，不满足pop，为后面的exam提供选择的可能（ans变小，T变大） 转①

代码示例

//结构体版
#include<bits/stdc++.h>
using namespace std;

const int maxn=2e5+10;

struct point{
    int t,limit,id;
}pt[maxn];

bool comp(point a,point b){
    return a.t<b.t;
}

struct cmp{//运算符重载
    //  limit小的在前面  ;limit一样的 t大的在前面
    bool operator()(const point &a,const point &b){
        if(a.limit==b.limit) return a.t<b.t;
        return a.limit>b.limit;
    }
};

priority_queue<point,vector<point>,cmp> que;

int main()
{
    ios::sync_with_stdio(false);
    int n,T,ans;
    ans=0;
    cin>>n>>T;
    for(int i=0;i<n;++i){
        cin>>pt[i].limit>>pt[i].t;
        pt[i].id=i+1;
    }
    sort(pt,pt+n,comp);//所需时间少的exam排在前面
    for(int i=0;i<n;++i){
        if(pt[i].t>T) break;//后面的时间铁定不行啦
        if(pt[i].limit>ans){//现在还行
            T-=pt[i].t;
            que.push(pt[i]);
            ans++;
        }
        while(!que.empty()&&que.top().limit<ans){//之前进去的可能不行啦 由于是优先队列
                //重载的是limit小的在前面  ;limit一样的 t大的在前面
                //所以先检验top的limit符不符合
            ans--;
            T+=que.top().t;
            que.pop();
        }
    }
    cout<<ans<<endl<<ans<<endl;
    while(!que.empty()){
        cout<<que.top().id<<' ';
        que.pop();
    }
    return 0;
}

E

思路

核心思想：数值取非、相与、相或对应表达式取非、相与、相或

另外就是“最短路”松弛思想更新最优解

细节见代码注释

代码示例

#include<bits/stdc++.h>
using namespace std;

char str[20];

int p;//是否继续“松弛”标志

string dp[256][3];//0表示非状态 1表示与状态 2表示或状态

void orz(string &a,string b)//判断是否更新a，若更新置p为1
{
    if(b.size()<a.size()||b.size()==a.size()&&b<a)
    {
        a=b;
        p=1;
    }
}

int main()
{
    for(int i=0;i<256;++i)
    for(int j=0;j<3;++j)
    for(int k=0;k<50;++k){
        dp[i][j]+="x";
    }
    dp[15][0]="x";//00001111  对应expression为x
    dp[51][0]="y";//00110011  对应expression为y
    dp[85][0]="z";//01010101  对应expression为z

    p=1;
    while(p)//注意先对“非”做更新 再对“与” 最后对“或”
    {
        p=0;//置0 若下面还有置1的操作则继续循环 直到p一直为0(无松弛的可能性)

        for(int i=0;i<256;++i){
            orz(dp[i][0],"!"+dp[i^255][0]);//异或取反 则逻辑值也相反 因此+!
            orz(dp[i][0],"!("+dp[i^255][1]+")");
            orz(dp[i][0],"!("+dp[i^255][2]+")");
        }


        for(int i=0;i<256;++i){
            for(int j=0;j<256;++j){//3*3 9种情况
                orz(dp[i&j][1],dp[i][0]+"&"+dp[j][0]);//枚举所有的i,j得到i&j，数值的与等价于表达式的与
                orz(dp[i&j][1],dp[i][0]+"&"+dp[j][1]);
                orz(dp[i&j][1],dp[i][0]+"&("+dp[j][2]+")");
                orz(dp[i&j][1],dp[i][1]+"&"+dp[j][0]);
                orz(dp[i&j][1],dp[i][1]+"&"+dp[j][1]);
                orz(dp[i&j][1],dp[i][1]+"&("+dp[j][2]+")");
                orz(dp[i&j][1],"("+dp[i][2]+")&"+dp[j][0]);//注意与的优先级高于或，因此要加括号
                orz(dp[i&j][1],"("+dp[i][2]+")&"+dp[j][1]);
                orz(dp[i&j][1],"("+dp[i][2]+")&("+dp[j][2]+")");
            }
        }

        for(int i=0;i<256;++i){
            for(int j=0;j<256;++j){//3*3 9种情况
                orz(dp[i|j][2],dp[i][0]+"|"+dp[j][0]);//枚举所有的i,j得到i&j，数值的与等价于表达式的与
                orz(dp[i|j][2],dp[i][0]+"|"+dp[j][1]);
                orz(dp[i|j][2],dp[i][0]+"|"+dp[j][2]);
                orz(dp[i|j][2],dp[i][1]+"|"+dp[j][0]);
                orz(dp[i|j][2],dp[i][1]+"|"+dp[j][1]);
                orz(dp[i|j][2],dp[i][1]+"|"+dp[j][2]);
                orz(dp[i|j][2],dp[i][2]+"|"+dp[j][0]);
                orz(dp[i|j][2],dp[i][2]+"|"+dp[j][1]);
                orz(dp[i|j][2],dp[i][2]+"|"+dp[j][2]);
            }
        }
    }

    int n;
    cin>>n;
    for(int i=0;i<n;++i){
        cin>>str;
        int k=0;
        for(int j=0;j<8;++j){
            k=k*2+(str[j]-'0');//转二进制
        }
        string ans=dp[k][0];//选取最优的表达式。当然他们的逻辑值相同，只是长短或者字典序不同
        orz(ans,dp[k][1]);
        orz(ans,dp[k][2]);
        cout<<ans<<endl;
    }
    return 0;
}

题解solution1

#include <iostream>
#include <set>
#include <vector>
#include <string>

using namespace std;

bool ls(const string& a, const string& b) {
    if (a.length() == b.length()) return a < b;
    return a.length() < b.length();
}

struct Expression {
    int p, t;
    string e;

    Expression(string _e, int t_, int _p) : e(_e), t(t_), p(_p) {}

    bool operator < (const Expression& ex) const {
        if (ex.e == e) {
            if (t != ex.t) {
                return t < ex.t;
            }
            return p < ex.p;
        }
        return ls(e, ex.e);
    }
};

set<Expression> q;

const int FULL = 0xff;
const vector<int> B = {1, 2, 4, 8, 16, 32, 64, 128};
const int X_TABLE = B[4] + B[5] + B[6] + B[7];
const int Y_TABLE = B[2] + B[3] + B[6] + B[7];
const int Z_TABLE = B[1] + B[3] + B[5] + B[7];

string dp[1 << 8][3];

void add(int pr, const string& s, int mask) {
    if (dp[mask][pr].empty() || ls(s, dp[mask][pr])) {
        dp[mask][pr] = s;
        Expression e(s, mask, pr);
        q.insert(e);
    }
}

int main() {
    add(2, "x", X_TABLE);
    add(2, "y", Y_TABLE);
    add(2, "z", Z_TABLE);
    while (!q.empty()) {
        auto e = *q.begin();
        q.erase(q.begin());

        if (e.p == 2) {
            add(2, "!" + e.e, ~e.t & FULL);
            add(1, e.e, e.t);
        }

        if (e.p == 1) {
            for (int mask = 0; mask < FULL; ++mask) {
                if (!dp[mask][2].empty()) {
                    add(1, dp[mask][2] + "&" + e.e, mask & e.t);
                    add(1, e.e + "&" + dp[mask][2], mask & e.t);
                }
            }
            add(2, "(" + e.e + ")", e.t);
            add(0, e.e, e.t);
        }

        if (e.p == 0) {
            for (int mask = 0; mask < FULL; ++mask) {
                for (int pr = 1; pr <= 2; ++pr) {
                    if (!dp[mask][pr].empty()) {
                        add(0, dp[mask][pr] + "|" + e.e, mask | e.t);
                        add(0, e.e + "|" + dp[mask][pr], mask | e.t);
                    }
                }
            }
            add(2, "(" + e.e + ")", e.t);
        }
    }


    int n;
    cin >> n;
    while (n--) {
        string s;
        cin >> s;
        int mask = 0;
        for (int i = 0; i < 8; ++i) {
            if (s[i] == '1') {
                mask |= (1 << i);
            }
        }

        cout << dp[mask][0] << endl;
    }

    return 0;
}