NOIP2012 简要题解

最新推荐文章于 2024-10-12 21:55:03 发布
最新推荐文章于 2024-10-12 21:55:03 发布
阅读量6.5k 收藏
点赞数
分类专栏： 2013 noip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KQZXCMH/article/details/8221162
版权
noip 同时被 2 个专栏收录
4 篇文章 0 订阅
订阅专栏
2013
2 篇文章 0 订阅
订阅专栏

Day1 P1 Vigenere密码

直接根据规律模拟即可

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 2000;
char S[maxn],T[maxn];
int calc(char c)
{
    return (int(c)-65-(c>=97?32:0));
}
int main()
{
    scanf("%s",S);
    scanf("%s",T);
    for (int i = 0 ; T[i]!='\0'; ++i)
    {
        for (int j = 0 ; j < 26; ++j)
        {
            if ((j+calc(S[i%strlen(S)]))%26 == calc(T[i])) 
               printf("%c",j+65+(T[i]>=97?32:0));
        }
    }
    return 0;
}


Day1 P2    国王游戏

首先我们分析一下 如果i和j两个相邻那么i排在j前面的必要条件是  total * a[i] / b[j]  <  total * a[j] /b[i] 也就是说 a[i]*b[i] < a[j]*b[j]

这样就立刻确定了顺序（有序性在信息学竞赛中的应用）

接下来就是模拟出每个大臣得到的数，直接使用一下高精度计算即可。 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#define INF 1000000000
using namespace std;
const int maxn = 200000;
struct big{
       int a[maxn],len;
       big(){ memset(a,0,sizeof(a)); len = 1;};
       string str() const
       {
              string res = "";
              for (int i = 0 ;i<len;++i)res= char(a[i]+'0')+res;
              return res;
       }
       big operator = (const char* num)
       {
           len = strlen(num);
           for (int i = 0;i < len;++i) a[i]=num[len-i-1]-'0';
           while (!a[len-1] && len>1) len--; 
           return *this;
       }
       big operator = (int num)
       {
           char s[maxn];
           sprintf(s, "%d", num);
           *this = s;
           return *this;
       }
       big operator * (int b)
       {
           big c ;
           c.len = len;
           for (int i = 0 ; i <c.len ; ++i)
               c.a[i] =  a[i]*b;
           for (int i = 0 ; i <c.len; ++i)
           {
               c.a[i+1]+=c.a[i]/10;
               c.a[i]%=10;
           }
           while (c.a[c.len]>0) 
           {
                 c.a[c.len+1]=c.a[c.len]/10;
                 c.a[c.len]%=10;
                 c.len++;
           }
           return c;
       }
       big operator /(int b)
       {
           big  c= *this;
           int x =0;
           for (int i = len-1; i >=0; i--)
           {
               int y  = (x*10+c.a[i])%b;
               c.a[i] = (x*10+c.a[i])/b;
               x = y;
           }
           /*if (x>0)
           {
               int i =0;
               do{
                    a[i]++;
                    if (a[i]>=10) a[i+1]++,a[i]-=10;else
                    break;
               }while(true);
           }*/
           while (c.a[c.len-1]==0 && c.len>1) c.len--;
           return c;
       }
       big operator +(const big & b)
       {
           big c;
           c.len = 0 ;
           for (int i =0, g=0; g|| i< max(len, b.len);++i)
           {
               int x = g;
               if (i<len)x+=a[i];
               if (i<b.len) x+=b.a[i];
               c.a[c.len++] = x%10;
               g=x/10;
           }
           return c;
       }
       big operator +=(const big &b) 
       {
           *this = *this + b;
           return *this;
       }
       big(int num) { *this = num;}
       big(const char* num){ *this = num ;}
       
       bool operator < (const big &b)const 
       {
           if (len!=b.len) return len<b.len;
           for (int i = len-1; i>=0; i--)
           if (a[i] != b.a[i]) return a[i]<b.a[i];
           return false; 
       }
       void       print()
       {
                  for (int i = len-1 ; i>=0;i--)
                  printf("%d",a[i]);
                  printf("\n");
       }
}ans,answer,t;
struct node 
{
       int x,y;
       bool operator <(const node& a) const 
       {
            return x*y < a.x*a.y;
       }
}p[maxn];
istream& operator >> (istream& in,  big &x)
{
         string s;
         in>>s;
         x = s.c_str();
         return in;
}
ostream& operator << (ostream& out, big &x)
{
   out<< x.str();
   return out;
}
int main()
{ 
    int n ;
    cin >> n ;
    for (int i = 0; i <=n ;++i)
        scanf("%d %d",&p[i].x,&p[i].y);
    sort(p+1, p+n+1);

    ans = p[0].x;
    answer = 0;
    for (int i = 1 ; i <=n; ++i )
    {
        t = ans / p[i].y;
        if (answer<t)  answer = t;
        ans =ans * p[i].x;
        //cout<<p[i].x<<" ";
        //ans.print();
    }
    answer.print();   
    return 0;
}

Day1 P3   开车旅行

A和B交替轮流开车一个选择最近的一个选择第二近的前进。
首先A和B交替前进可以看做是A+B一个整体前进。然后最后一步特殊处理即可。

然后关于找最近的点和第二近的点，类似于找前驱和后继，C++可以中set实现，至于Pascal语言，可以考虑平衡术，但是难度太大，还是用二叉查找树。

然后利用路径上的倍增思想,f[i][j]表示i点前进2^j次步走到了多少，g[i][j]表示i节点前进2^j次步走到哪个节点。 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <set>
#include <cmath>
using namespace std;
const int maxn = 200000+10;
typedef long long LL;

int g[maxn][20+2],next1[maxn],next2[maxn];
LL  len1[maxn],len2[maxn];
LL lenA,lenB;
int n,m,i,j;
struct    road
{
   LL A,B;
   
   road operator +(const road &a)
   {    
        road c;
        c.A = A + a.A;
        c.B = B + a.B;
        return c;
   }
}f[maxn][20+2];
struct    Point
{
    int id, h;
    bool operator<(const Point &a) const
    {
         return h < a.h;
    }
}p[maxn];
multiset<Point> S;
multiset<Point>::iterator it;
void      updata(int i ,int h,int j,int h2)
{
          if (!next1[i])
          {
              next1[i] =  j;
              len1[i]= abs(h-h2);
              return ;
          } 
          if ((abs(h-h2) == len1[i] && p[next1[i]].h > h2)
          ||  (abs(h-h2) < len1[i]))
          {
              next2[i] = next1[i];
              len2[i]  = len1[i];
              
              next1[i] = j;
              len1[i]  = abs(h-h2);      
              return ;     
          }
          if (!next2[i])
          {
              next2[i] =  j;
              len2[i]= abs(h-h2);
              return ;
          } 
          if ((abs(h-h2)== len2[i] && p[next1[i]].h > h2)
          ||  (abs(h-h2) < len2[i]))
          {
              next2[i]=  j;
              len2[i] = abs(h-h2);
          }
}
void      ask(int st,LL len)
{
          for (int j = 20; j >=0; j--)
          {
              if (g[st][j]!=0 && f[st][j].A+f[st][j].B<=len)
              {
                  len -= (f[st][j].A+f[st][j].B);
                  lenA+=f[st][j].A;
                  lenB+=f[st][j].B;
                  st = g[st][j];            
              }
          }
          if (next2[st] && len>=len2[st])
             lenA +=len2[st];
}
int main()
{
    cin>>n;
    for (int i = 1; i <= n; ++i)
    {
         scanf("%d", &p[i].h);
         p[i].id = i;
    }
    for (int i = n; i>=1; --i)
    {
        it = S.lower_bound(p[i]);
        if (it != S.end())
           updata(i , p[i].h, it->id, it->h);
        
        if (it != S.end())
        {
               it++;
               if (it != S.end())
               updata(i , p[i].h, it->id, it->h);
               it--;
        }
        
        if (it != S.begin())
        {
               it--;
               updata(i , p[i].h, it->id, it->h);
        }
        if (it != S.begin())
        {
               it--;
               updata(i , p[i].h, it->id, it->h);
        }
        S.insert(p[i]);
    }
    
    for  (int i = 1; i <= n;++i)
    {
         //cout << next2[i]<<" "<<len2[i]<<endl;
         g[i][0] = next1[next2[i]];
         f[i][0].A =  len2[i];
         f[i][0].B =  len1[next2[i]];
    }
    for (int i = 1; i <= 20; ++i)
    for (int j = 1; j <= n;++j)
    {
        g[j][i] = g[g[j][i-1]][i-1];
        /*f[j][i].A = f[j][i-1].A + f[g[j][i-1]][i-1].A;
        f[j][i].B = f[j][i-1].B + f[g[j][i-1]][i-1].B;
        if (f[2][0].A==3)
        cout<<i <<" "<<j << endl;
        */
        f[j][i]= f[j][i-1]+ f[g[j][i-1]][i-1];
    }
    LL x;
    cin>>x;
    LL ansA = (LL)round(10e9);
    LL ansB = 0;
    int Pos = 0;
    for (int i = 1; i <= n;++i)
    {
             lenA = lenB = 0;
             ask(i,x);
             //cout << lenA<<" "<<lenB<<endl;
             if (lenB != 0)
             {
                 if (Pos ==0 || ansA*lenB > lenA * ansB)     
                 {
                      Pos = i;
                      ansA = lenA;
                      ansB = lenB;
                 }
             }
    }
    cout << Pos << endl;
    cin>>m;
    for (int i = 1; i <= m; ++i)
    {
        int st;
        scanf("%d %d",&st,&x);
        lenA = lenB = 0;
        ask(st,x);
        cout<<lenA<<" "<<lenB <<endl;
    }
    return 0;
}



Day2 P1   同余方程 详见前面文章的两种解法（除了扩展欧几里得和分块外，还可以用费马定理做）。

Day2 P2    借教室
 
首先本题就是整体减一个值，看看数组里有木有值被减成了负数，这个可以用线段树维护最小值即可，看数组中的最小值是否为负数。 
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>

using namespace std;
const int maxn = 1000000+10;

int a[maxn];
int n,m,s,t,need;
struct node
{
       int Min[maxn*4];
       int dec[maxn*4];
       void   build(int a[],int l,int r,int p)
       {
              dec[p]=0;
              if (l==r)
              {
                  Min[p] = a[l];
                  return ;
              }
              int mid = (l+r) / 2;
              build(a,l,mid,p+p); 
              build(a,mid+1,r,p+p+1);
              Min[p] = min(Min[p+p],Min[p+p+1]);  
       }
       void   update(int p )
       {
              Min[p] = min(Min[p+p]-dec[p+p],Min[p]);
              Min[p] = min(Min[p+p+1]-dec[p+p+1],Min[p]);
       }
       void   push(int p)
       {
              dec[p+p]+=dec[p];
              dec[p+p+1]+=dec[p];
              dec[p]=0;
       }
       void   getDec(int l ,int r,int p, int a,int b,int need)
       {
              if (l==a && r==b)
              {
                  Min[p]-= (need+dec[p]);
                  if (l!=r) dec[p+p]+=dec[p]+need,dec[p+p+1]+=dec[p]+need;
                  dec[p]=0;
                  return ;
              }
              push(p);
              int mid = (l+r) / 2;
              if (b <= mid ) getDec(l,mid,p+p,a,b,need); else
              if (a >  mid ) getDec(mid+1,r,p+p+1,a,b,need); else
              {
                 getDec(l, mid ,p+p,a,mid,need);
                 getDec(mid+1,r,p+p+1,mid+1,b,need);   
              } 
              update(p);
       }
       
}tree;
int main()
{
    cin >> n >> m ;
    for (int i = 1; i <= n ;++i ) scanf("%d",&a[i]);
    tree.build(a,1,n,1);
    
    for (int i = 1; i <= m ;++i)
    {
        scanf("%d %d %d",&need, &s,&t);
        tree.getDec(1,n,1,s,t,need);
        if (tree.Min[1] < 0 )
        {
            printf("%d\n%d\n",-1,i);
            return 0;
        }
    }
    cout << 0 << endl;
    return 0;
}

 Day2 P3  疫情控制
题目大意即所有军队拦截住1节点通往叶节点的道路。

首先答案最小，可以用二分转化为判定性问题。

第二继续利用倍增思想判断军队能否达到1节点。能则记录还有多少时间可以移动，不能则停留在最上面的节点上。
然后根据目前情况DFS出1的那几个子节点需要军队，然后就是军队与子节点的一一匹配。
这个匹配可以用贪心，首先而比边的权值排序从大到小操作，对于1的某个自己点，如果有军队从他走到了1，但是回不到自身了，则
让该军队控制这个节点，否则选出还有时间能够走到该节点的剩余时间最小的军队去控制这个节点（可以用一个set，方便查找）。 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <set>
#include <map>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn = 100000;
typedef long long LL;
multiset<int> S;
multiset<int>::iterator it;
int n,u,v,w,m,nownode;
LL f[maxn][20];
int y[maxn];
int g[maxn][20];
int sonTree[maxn];
int cnt[maxn];
int p[maxn];
int Min[maxn]; 
bool Leaf[maxn];
bool son[maxn];
struct    Arm
{
          int opt,time;
}A[maxn]; 
struct    Graph
{
     int node[maxn * 2], len[maxn * 2], next[maxn * 2], v[maxn * 2];
     int en;
     Graph(){ 
        memset(v,0,sizeof(v));
        memset(next,0, sizeof(next));
        memset(len,0,sizeof(len));  
        en  = 0; 
     }
     void   addEdge(int a,int b,int c)
     {
            en++; node[en] = b; len[en] = c; next[en] = v[a]; v[a] = en;
            en++; node[en] = a; len[en] = c; next[en] = v[b]; v[b] = en;
     }
}G;
void     DFS(int x,int father)
{
         sonTree[x] = nownode;
         bool flag= true;
         for (int j = G.v[x]; j; j = G.next[j])
         {
             if (G.node[j] != father)
             {
                 //father[j] = x;
                 flag = false;
                 f[G.node[j]][0] = G.len[j];
                 g[G.node[j]][0] = x;
                 if (x==1) nownode = G.node[j];
                 DFS(G.node[j],x); 
             }
         }
         Leaf[x] = flag;
}
void     find_leaf(int x, int father)
{
         if (cnt[x]>0) return ;
         if (Leaf[x])
         {
             son[nownode] = true;
             return;
         }
         for (int j = G.v[x]; j ; j = G.next[j])
         {
             if (G.node[j] != father)
             {
                 if (x==1) nownode = G.node[j];
                 find_leaf(G.node[j], x);
             }
         }
}
bool     ok(LL value)
{
    S.clear();
    int arm = 0;
    memset(cnt,0,sizeof(cnt));
    memset(son,0,sizeof(son));
    for (int i = 1; i <= m ;++i)
    {
        int len = value;
        int Pos = p[i];
        for (int j = 16; j>=0; --j)
            {
                 if (f[Pos][j]<=len && g[Pos][j]!=0)
                 {
                     len-=f[Pos][j];
                     Pos =g[Pos][j];              
                 }
            }
        if (Pos == 1)
        {
            A[arm].opt = p[i];
            A[arm++].time  = len;
        } else
          cnt[Pos]++;
    }           
    find_leaf(1,0); 
    for (int i = 1;i <= n;++i) Min[i]= -1;
    for (int i = 0; i < arm ; ++ i)
    {
        if (son[sonTree[A[i].opt]])
        {
           if  (Min[sonTree[A[i].opt]] ==-1 || 
              A[Min[sonTree[A[i].opt]]].time > A[i].time)
                Min[sonTree[A[i].opt]] = i;
        }
    } 
    int tot = 0;
    for (int i = 1; i <= n;++i)
    {
        if (son[i] && Min[i] != -1 && A[Min[i]].time<f[i][0])
        {
            A[Min[i]].time = -1;       
        }else
        if (son[i]) y[tot++] = f[i][0];
    }
    sort(y,y+tot);
    for (int i = 0; i < arm;++i)
    if (A[i].time != -1)
        S.insert(A[i].time);
        
    for (int i = tot-1; i>=0; --i)
    {
        if (S.lower_bound(y[i]) == S.end()) return false;
        it = S.lower_bound(y[i]);
        S.erase(it);
    }
    return true;
}
int main()
{
    cin>>n;
    for (int i = 1;i < n;++ i)
    {
        scanf("%d %d %d",&u,&v,&w);
        G.addEdge(u,v,w);
    }
    cin>>m ;
    for (int i = 1;i <= m;++i)
    {
        scanf("%d", &p[i]);
        // cnt[p[i]] ++;
    }
    DFS(1,0);
    /*for (int i = 1;i <= n; ++i)
    {
        cout <<i<<" "<<f[i][0]<<" "<<g[i][0] << endl; 
    }*/
    for (int i = 1; i <=16; ++i)
        for (int j = 1; j <= n ;++j)
        {
            f[j][i] = f[j][i-1]+ f[g[j][i-1]][i-1];
            g[j][i] = g[g[j][i-1]][i-1];
        }
    
    
    LL L = 0 , R = (LL)n * round(10e9);
    int ans = -1;
    while (L <= R)
    {
          LL mid = (L+R) /2;
          if (ok(mid)) R = mid-1, ans = mid; 
          else L = mid+1;
    }
    cout << ans << endl;
    return 0;
}


ngncmh
关注
专栏目录
NOIP2012提高组day1题解
beautiful_CXW的博客
07-06 1038
1.Vigenère密码   一开始以为是明码反暗码，就直接把密码表预处理，然后测了多好多遍还是没过样例，十分困惑与不解然后就看一了一遍题目（咳，   暗码减去密码取模   这一遍很自信然后爆零了   （输出区分大小写 #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;iostream&gt; #include&lt;algo...
题解 [NOIP2022] T1 种花
wzliwzli的博客
12-03 1944
NOIP2022 T1 种花(plant) 题解
NOIP2012题解
weixin_30952535的博客
10-20 132
T1Vigenère 密码 传送门 题解：字符串模拟 代码： #include <cstdio> #include <cstring> #include <iostream> using namespace std; char k[1010],s[1010],ans[1010]; int len1,len2; int main() ...
【题解】【数学】—— [NOIP2012 普及组] 质因数分解
最新发布
Pantheraonca的博客
10-12 1064
蓝胖子编程教育，是一家面向青少年的编程教育平台。平台为全国青少年提供最专业的编程教育服务，包括提供最新最详细的编程相关资讯、最专业的竞赛指导、最合理的课程规划等。本平台利用趣味性和互动性强的教学方式，旨在激发孩子们对编程的兴趣，培养他们的逻辑思维能力和创造力，让孩子们在轻松愉快的氛围中掌握编程知识，为未来科技人才的培养奠定坚实基础。我们可以考虑枚举较小的质因数，从而找到较大的质因数。是两个不同的质数的乘积，试求出两者中较大的那个质数。NOIP 2012 普及组 第一题。，即较大的那个质数。
NOIP2012day2题解
PbTfcLx
05-17 1938
同余方程： 题目大意：求关于 x 同余方程 ax ≡ 1 (mod b)的最小正整数解。 题解： 就是一道裸的求同余方程……直接贴一个扩展欧几里得即可。根据费马定理&&同余的定理，我们可以得出ax ≡ 1 (mod b)等价于ax-by=1等价于ax+by=gcd(a,b)。 这里给出扩展欧几里得解ax+by=gcd(a,b)的证明（或者说步骤）。 ax1+by1=gcd(a,b)=gcd
NOIP2012day1题解
PbTfcLx
05-07 1274
Vigenere密码： 题目大意：给你一个密文和密钥，密文=第（密钥+明文）%26位字母，且密文的大小写要与明文相同，求明文。密钥长度<=100，密文长度<=1000. 题解： 直接模拟即可，可以得出明文=密文-密钥，如果小于0的话+26再加上相应的A或a即可。时间复杂度：O(n)，空间复杂度：O(n)。#include<cstdio> #include<cstring> #include<c
noip2012day2题解
Amuseir的博客
07-23 316
T1 同余方程 恩。。。exgcd。。对于会的人来说这道题基本等于水题吧 #include&lt;cstdio&gt; void exgcd(long long a,long long b,long long &amp;x,long long &amp;y) { if(!b) { x=1; y=0; return; } else { exgcd(b,a%b,y,x...
noip2008普及组复赛试题(附题解)
07-25
以上就是对 NOIP2008 普及组复赛试题的简要解答，其中涉及到的算法和数据结构是编程中比较常见的基础知识，通过理解和掌握这些知识，可以帮助我们更好地解决类似的编程问题。 ### 回答2： NOIP（全国青少年信息学...
[CSP-S 2021] 括号序列 详细题解
yds_creator的博客
09-13 509
写了这篇题解来详细谈谈这题的思维过程和做题时 dp 状态的逐步建立过程，同时稍稍改良了一下大佬的做法，少用了一个状态，希望这篇题解能帮到大家 qwq。定义dpijpdp_{i,j,p}dpijp​为在SSS的区间ij[i,j]ij中确定?
noip 2017 做题记录
weixin_42975971的博客
11-04 214
noip 2017 小凯的疑惑 最大不可表数。 以前写过 这篇博客 时间复杂度 恶心的模拟题…… 推荐食用洛谷第一篇题解，写的很好。 getline 简要讲解 读入一个单词时，可用 cin/scanf。读入一行带空格的字符时，可用getline。（我只会这几个，而且它们用起来比较方便因为我太懒了 ）。 我写的与洛谷题解稍有不同，因为他读入字符串的方法感觉很高级其实是看不懂 。 #include&l...
P5022 旅行 题解
bifanwen的博客
04-04 525
原题链接 简要题意： 给定一棵树（或基环树），每个节点只能至多回溯一次，求遍历整棵树的最小字典序。 基环树概念：树多一条边，即树上出现且仅出现一个环。 作为 NOIP2018 Day2 T1\texttt{NOIP2018 Day2 T1}NOIP2018 Day2 T1，确实有些难度。不过我们从部分分开始想。 对于 60%60 \%60% 的数据，给定的是...
NOIP2012年普及组试题+数据+解题报告
11-02
NOIP2012普及组试题，测试数据,题解报告，报告很详细的引导初学导解题
【NOIp】NOIp2012
weixin_30539625的博客
09-18 199
NOIp 2012 day 1 T1 Vigenère 密码 标签：模拟 主要是用了ASCII码，字母'A'的ASCII码是41H（0100 0001B），字母'a'的ASCII码是61H（0110 0001B），字母'A'与'a'的二进制后5位是相同的，所以无论是大写字母还是小写字母x，x &31（1 1111B）的值就是x在字母表里的顺序。 简单判一下边界就行了 c...
NOIP2012——文化之旅
布拉克王国
03-11 754
这道题最初博主理解错误，误以为学了某种文化就不能到排斥这种文化的地方去（明明也是这样写的好吧），实际上只用判断到达的国家是否排斥现在所在国家的文化，那就简单多了，Floyd 走起，下面是代码： #include &lt;stdio.h&gt; using namespace std; const int MAX=999999; const int MAXN=105; int n,k...
7.16 NOIP 2012
Elaiza_的博客
07-17 180
NOIP 2012 DAY 1 T1 Vigenère密码 纯模拟 #include<bits/stdc++.h> char a[105],b[1005],ans[1005]; int len1,len2,h=1,p; int c[105]; using namespace std; int main(){ // freopen("vigenere.in","r",stdin); ...
NOIP2012——寻宝
布拉克王国
03-11 1087
看到这道题，我就想到了直接根据行走路径进行操作，结果 ——一片WA ，悲伤，那么除了这样，怎么解决呢？ 我们用到的方法是用数组存储每层楼有向上楼梯的个数，以及每个房间的情况，然后将要走的次数模上总个数，再用得到的值加上最初的房间，即可。下面是代码： #include&lt;bits/stdc++.h&gt; using namespace std; const int N=100...
NOIP2012 疫情控制
Morning_Glory_JR的博客
10-23 943
也许更好的阅读体验 Description\mathcal{Description}Description 原题链接 一句话题意 一个人可以堵住一个子树，不能一次堵住整棵树，求堵住每个通往叶子节点的路径，走的最远的那个人走的路程最少是多少，若不能堵住输出−1-1−1 Solution\mathcal{Solution}Solution 看了下其他题解,都说很毒瘤 最开始我也认为很毒瘤 就是在决...
noip2012 day1
chang_yl的博客
07-16 302
简单模拟。规律的话就是密匙中A代表加0，B代表加1，以此类推。于是先把密匙大小写同一，然后与A减，得到的再用密文减即可。 需要注意的一点就是密文大小写一开始就定下来了，如果减过了‘a’或者‘A’的话，依照表的规律的话要改成‘Z’或‘z’减掉溢出。 #include&lt;bits/stdc++.h&gt; using namespace std; #define RG register ...
NOIP2012 普及组 T4 文化之旅
Stockholm_Sun的博客
05-01 1496
文化之旅（NOIP2012 普及组 T4 ）题目描述有一位使者要游历各国，他每到一个国家，都能学到一种文化，但他不愿意学习任何一种文化超过一次（即如果他学习了某种文化，则他就不能到达其他有这种文化的国家）。不同的国家可能有相同的文化。不同文化的国家对其他文化的看法不同，有些文化会排斥外来文化（即如果他学习了某种文化，则他不能到达排斥这种文化的其他国家）。现给定各个国家间的地理关系，各个国家的文化，每
noip历年真题题解.pdf
09-28
《NOIP历年真题题解.pdf》是一本关于NOIP（全国青少年信息学奥林匹克竞赛）历年真题的解析书籍。这本书的目的是帮助学生更好地理解和掌握NOIP竞赛中的题目，并提供对解题思路的详细解释和讲解。 这本书一般会包含多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值