hrbust 1481

  1   /*  构造特定条件的68序列：给定目标串中6 8 68 86 这四种字串的个数a b p q ，输出所有满足条件的字符串中代表的数字最小的那个 
  2           //  hrboj 1481  _______________________________________________________________________
  3               //#include<bits/stdc++.h>     
  4               #include<iostream>
  5               #include<string>
  6               #include<cstdio>
  7 
  8               using namespace std;  
  9               typedef long long  ll;
 10               typedef pair<ll,ll> pll;  
 11               #define pb(x) push_back(x)   
 12               #define ss(x) scanf("%s",x)
 13               #define sd(x) scanf("%d",&x) 
 14               #define sll(x) scanf("lld",&x)
 15               typedef unsigned long long  ull;     
 16               #define mem(A, X) memset(A, X, sizeof A)
 17               #define ford(i,l,u) for(ll (i)=(ll)(l);(i)>=(ll)(u);--(i))
 18               #define foreach(e,x) for(__typeof(x.begin()) e=x.begin();e!=x.end();++e)
 19               #define fori(i,l,u) for(ll (i)=(ll)(l);(i)<=(ll)(u);++(i))
 20               #define delete_this freopen("in.txt","r",stdin)
 21               #define sd2(x,y) scanf("%d%d",&x,&y)
 22               #define slf(x) scanf("%lf",&x)
 23               #define sc(x) scanf("%c",&x)
 24               #define sec second
 25               #define fir first  
 26 
 27               const ll mod=1e9+7; 
 28               const ll maxn=1e5+10; 
 29               int a,b,p,q; 
 30               void out6(int a )
 31               {
 32                   fori(i,1,a) printf("6");
 33               }
 34               void out8(int a )
 35               {
 36                   fori(i,1,a) printf("8");
 37               }
 38               void out68(int a )
 39               {
 40                   fori(i,1,a) printf("68");
 41               } 
 42               int main()
 43               {
 44                    //delete_this;  
 45                    while(cin>>a)
 46                    {                        
 47                         cin>>b>>p>>q; 
 48                         int flag=1;  
 49                         if(a==p)
 50                         { 
 51 
 52                               if(q==p)
 53                               { 
 54 
 55                                      if(b>=p+1)
 56                                     { 
 57                                           flag=0;
 58                                           out8(1);
 59                                           out68(p);
 60                                           out8(b-p-1); 
 61                                     } 
 62                               }
 63                                     else if(q==p-1)
 64                                     {
 65                                           if(b>=p)
 66                                           {
 67                                                 flag=0;
 68                                                 out68(p);
 69                                                 out8(b-p); 
 70                                           } 
 71                                     }
 72 
 73 
 74                         }
 75                               else if(a>p)
 76                               {
 77                                     if(q==p)
 78                                     {
 79                                           if(b>=p)
 80                                           {
 81                                                 flag=0; 
 82                                                 out6(a-(p+1));
 83                                                 out68(p);
 84                                                 out8(b-p);
 85                                                 out6(1); 
 86                                           } 
 87                                     }
 88                                           else if(q==p-1)
 89                                           {
 90                                                 if(b>=p)
 91                                                 { 
 92                                                       flag=0;
 93                                                       out6(a-p);
 94                                                       out68(p);
 95                                                       out8(b-p); 
 96                                                 } 
 97                                           }
 98                                                 else if(q==p+1)
 99                                                 {
100                                                       if(b>=p+1)
101                                                       {
102                                                             flag=0;
103                                                             out8(1);
104                                                             out6(a-p-1);
105                                                             out68(p);
106                                                             out8(b-p-1);
107                                                             out6(1);
108                                                       }
109                                                 }
110 
111                               } 
112 
113                         if(flag) puts("-1");
114                         else puts("");    
115                    }
116 
117                 return 0;
118               }
119   
120              /*

分析： 记目标串有a个6，b个8,p个68子串，q个86子串。
6和8的个数是固定的，于是字符串的长度固定。 现在尝试对所有可能存在解的情况进行构造。
这里选择a,p的个数的关系分情况进行讨论，并在之后选择优先放置68 86这类子串（反过来的话可能会比较复杂）。
所有的可能存在解的情况分为（1）a==p  （2）a>p

121                 note    :   构造类的问题  分类逻辑分支都进行讨论到 是很关键的，在保证不重不漏的情况尽量简化。
122                               此外有一些很好的思路： 考虑某些关键性变量，通过进行限制，减少分类的情况进行简化。比如这里选择68为分类标准。
123                                                       考虑那些确定的量 ，单个6 8的个数，因为其没有重复，可以作为考虑的依据和数字长度的确定。
124                                                       考虑构造的先后次序，哪些重要，哪些不重要。这里优先68 然后86。之后的单个数字就很好处理了
125                 debug   :   68可能比86少一个是有可能的，即代码中的else if q==p+1的这一分支，  具体的例子 比如  868686，2个68,3个86.
126                 optimize:   一些重复性的操作---->函数简化。
127                             只考虑可能产生解的逻辑分支，其他else不管。
128               */