Codeforces Round #275 (Div. 2) 题解

A 题： 说的是在（LR） 之间找出ab互质 bc 互质 ac 不互质的 3个数 数据量小直接暴力

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string.h>
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b){
   return b==?a:(gcd(b,a%b));
}
int main()
{
     ll L,R;
     while(scanf("%I64d%I64d",&L,&R)==){
         bool falg=false;
         for(ll i=L; i<=R-; ++i){
               for(ll j=i+; j<=R-; ++j){
                   ll f= gcd(i,j);
                   if(f!=) continue;
                     for(ll e = j+; e<=R; ++e){
                           f = gcd(e,j);
                           if(f!=) continue;
                           f=gcd(i,e);
                           if(f==) continue;
                           falg=true;
                           printf("%I64d %I64d %I64d\n",i,j,e);
                           break;
                     }
                     if(falg) break;
               }
              if(falg) break;
         }
         if(falg==false) puts("-1");
     }

    return ;
}

B 题： 说的是找出cnt1 + cnt2 个质数然后 他们各不相同 cnt1 个不是x倍数的 cnt2 个不是y倍数的，分配完这些数后最大值最小

这样二分最大值，假设在mid 内 x 倍数为 px y的为py xy的为pxy 那么优先将 px-pxy的分给cnt2 把 py-pxy分给cnt1 这样接下来判段剩下的是否可以分配给cnt1和cnt2 剩余的 这样不断二分下去

#include <cstdio>
#include <string.h>
#include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
ll cnt1,cnt2,x,y;
ll maxv(ll a, ll b){ return a>b?a:b; }
bool solve(ll mid){
    ll a1 = mid/x;
    ll b1 = mid/y;
    ll c1 = mid/(x*y);
    ll acnt1 = maxv(cnt1 - (b1-c1),0LL);
    ll acnt2 = maxv(cnt2 -  (a1-c1),0LL);
    ll lest = mid-(a1+b1-c1);
    if(lest>=(acnt1+acnt2)) return true;
    else return false;
}
int main()
{

      while(scanf("%I64d%I64d%I64d%I64d",&cnt1,&cnt2,&x,&y)==){
           ll R = 9223372036854775807LL;
           ll L=;
            ll ans;
            while(R>=L){
               ll mid = (R+L)/;
               if(solve(mid)){
                 ans=mid; R=mid-;
               }else{
                  L=mid+;
               }
           }
           printf("%I64d\n",ans);
      }
      return ;
}

C 题： 输的是给了n个数 你写出n的一个排列使得 相邻的数的差值有k个不同的值，然后这n个数必须是1—n 不能重复，这样不断的往两边取 直到有k个不同的

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string.h>
#include <set>
using namespace std;
typedef long long ll;
const int maxn = ;
int ans[maxn];
set<int>Q;
int main()
{
    int n,k;
    while(scanf("%d%d",&n,&k)==){
          int L=;
          int num=;
          int R=n+;
          int now=;
          ans[]=;
          for(int i=; i<k; ++i){
             now=-now;
             if(now==){
                 L++;
                 ans[num]=L;
                 num++;
             }else{
                 R--;
                 ans[num]=R;
                 num++;
             }
          }
         if(num<n){
             if(now==){
                 for(int i=R-; i>L; i--) ans[num++]=i;
             }else{
                  for(int i=L+; i<R; i++) ans[num++]=i;
             }
         }
         for(int i=; i<n; ++i){
             printf("%d%c",ans[i],i==(n-)?'\n':' ');
         }
    }

    return ;
}

D题： 说的是给了n个数 m次操作 然后给了他们区间&后的值 这样问他们与后是否是合法的，我们知道给了区间& 的结果 也就是区间内的值每个都|上了这个值才能保证他们都具有相同的值

这样然后 将给的区间全部或上 q 然后 最后在按照 题目给的& 上一次 一旦出现与答案不符就证明是错误的

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string.h>
using namespace std;
const int maxn = ;
int cL,cR,W,b,n;
struct Itree{
      int V[maxn*];
      void pushdown(int o){
          V[o*]|=V[o];
          V[o*+]|=V[o];
          V[o]=;
      }
      void build(int o, int L, int R){
            if(L==R) return ;
            pushdown(o);
            int mid=(L+R)/;
            build(o*,L,mid);
            build(o*+,mid+,R);
            V[o]=V[o*]&V[o*+];
      }
      void update(int o, int L, int R){
          if(cL<=L&&R<=cR){
              V[o]|=W;
              return;
          }
          pushdown(o);
          int mid=(L+R)/;
          if(cL<=mid)
             update(o*, L, mid);
          if(cR>mid) update(o*+,mid+,R);
      }
      void query(int o, int L, int R){
           if(cL<=L&&R<=cR){
                if(b==)
                 W=V[o];
                 else W=W&V[o];
                 b=;
              return ;
           }
           int mid=(L+R)/;
           if(cL<=mid) query(o*,L,mid);
           if(cR>mid) query(o*+,mid+,R);
      }
      void print(int o, int L, int R){
            if(L==R){
                printf("%d%c",V[o],L==n?'\n':' ');
              return ;
            }
            int mid = (L+R)/;
            print(o*, L, mid);
            print(o*+,mid+,R);
      }
}T;
int LL[maxn],RR[maxn],QQ[maxn];
int main()
{
    int m;
    while(scanf("%d%d",&n,&m)==){
          memset(T.V,,sizeof(T.V));
          for(int i=; i<m; ++i){
             scanf("%d%d%d",&LL[i],&RR[i],&QQ[i]);
             cL=LL[i];
             cR=RR[i];
             W=QQ[i];
             T.update(,,n);
          }
          bool falg=true;
          T.build(,,n);
          for(int i=; i<m; ++i){
              b=;
              cL=LL[i];
              cR=RR[i];
              T.query(,,n);
              if(QQ[i]!=W){
                  falg=false; break;
              }
          }
         if(falg==false){
             printf("NO\n");
         }else {
             printf("YES\n");
             T.print(,,n);
         }
    }
    return ;
}

E 题说的 你把每个串从其他串中区别出来的期望步数， 状态压缩live[S] 表示 S 这个状态中有多少个串需要在选字母，然后dp[S] 表示到达这个状态的概率 ，对于每个一个S 有相应的期望

#include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
using namespace std;
double dp[<<];
char str[][];
long long live[<<];
int main()
{
     int n;
     while(scanf("%d",&n)==){
         memset(live,,sizeof(live));
         memset(dp,,sizeof(dp));
         for(int i=; i<n; ++i){
             scanf("%s",str[i]);
         }
         int m=strlen(str[]);
         for(int i=; i<n; ++i){

              for(int j=i+; j<n; ++j )
                 {
                     int S=;
                   for(int k=; k<m; ++k)
                     if(str[i][k]==str[j][k])
                       S|=(<<k);
                    live[S]|=(1LL<<i)|(1LL<<j);
                 }
         }
         for(int S = (<<m)-; S>; --S){
             for(int i=; i<m; ++i)
                if(S&(<<i)) live[S^(<<i)]|=live[S];
         }
         dp[]=;
         double ans=;
         for(int S=; S<<<m; ++S){
               int num=;
               for(int i=; i<n; ++i)
                 if(live[S]&(1LL<<i)) num++;
               ans+=dp[S]*num;
               num=;
               for(int i=; i<m; ++i)
                 if(S&(<<i)) num++;
               for(int i=; i<m; ++i)
                 if( (S&(<<i)) ==  )
                  dp[ S|(<<i) ]+= dp[S]/(m-num);
         }
         printf("%.15lf\n",ans/n);
     }
     return ;
}