QAQ QAQ QAQ（个人赛，是场穷游，偶尔能会一个两个的)

最新推荐文章于 2021-02-27 22:56:43 发布

求文拳王

最新推荐文章于 2021-02-27 22:56:43 发布

阅读量401

点赞数 1

分类专栏： SDUT-C语言-数据结构-acm 文章标签： QAQ系列

本文链接：https://blog.youkuaiyun.com/ggqinglfu/article/details/81904585

版权

SDUT-C语言-数据结构-acm 专栏收录该内容

41 篇文章

订阅专栏

1.%*c 作用——读取输入流中数字后的一个字符，并丢弃，使得后面的输入函数不能读到那个字符
跳过一个字符

int n;
    int s[20],i,len;
    char str[20];
    scanf("%d%*c",&n); // “*”符:用以表示该输入项,读入后不赋予相应的变量，即跳过该输入值
    while(n--)
    {
        gets(str);

2 语法: c++中c_str()用法
const char *c_str();
c_str()函数返回一个指向正规C字符串的指针, 内容与本string串相同.
这是为了与c语言兼容，在c语言中没有string类型，故必须通过string类对象的成员函数 c_str()把string 对象转换成c中的字符串样式。
注意：一定要使用strcpy()函数等来操作方法c_str()返回的指针
比如：最好不要这样:

char* c;
string s="1234";
c = s.c_str(); //c最后指向的内容是垃圾，因为s对象被析构，其内容被处理
//应该这样用：
char c[20];
string s="1234";
strcpy(c,s.c_str());

这样才不会出错，c_str()返回的是一个临时指针，不能对其进行操作
再举个例子
c_str() 以 char* 形式传回 string 内含字符串
如果一个函数要求char*参数，可以使用c_str()方法：
string s = “Hello World!”;
printf(“%s”, s.c_str()); //输出 “Hello World!”

3 什么是弃九数？
一个数除以9的余数叫弃九数。如84÷9=9……3，84的弃九数是3。
我们可以把一个数，每位数字加起来，继续加，直到结果是一位数（如果是9再减9是0），如8+4=12。1+2=3。
在考试中，对计算（尤其是整数、小数）四则运算的结果，如果去检验，总是感觉时间成本太大，现在向同学们隆重推荐“弃9法快速验题”，可以大幅度节约时间。
利用被9除所得余数的性质，对四则运算的结果进行检验的一种方法，叫“弃9验算法”。
用此方法验算，首先要找出一个数的“弃9数”，即把一个数的各个数位上的数字相加，如果和大于9或等于9都要减去9，直至剩下的一个小于9的数，我们把这个数称为原数的“弃9数”。
在应用中，可以把数值为9的数字或相加得9的几个数字直接划去，然后将剩下来的数字相加得到一个小于9的数，这个数就是原数的弃9数。
弃九验算法
（以上内容摘自百度百科知道，若有侵权，呃呃算了吧）

map 容器

map是C++ STL的一种关联容器，它是一种一对一的数据处理方式，

map的基本格式：

map<typename,typename>自定义的名字；比如map<int,string>studentMap;



map的基本操作函数：

      C++ Maps是一种关联式容器，包含“关键字/值”对
      begin()          返回指向map头部的迭代器
      clear(）         删除所有元素
      count()          返回指定元素出现的次数
      empty()          如果map为空则返回true
      end()            返回指向map末尾的迭代器
      equal_range()    返回特殊条目的迭代器对
      erase()          删除一个元素
      find()           查找一个元素
      get_allocator()  返回map的配置器
      insert()         插入元素
      key_comp()       返回比较元素key的函数
      lower_bound()    返回键值>=给定元素的第一个位置
      max_size()       返回可以容纳的最大元素个数
      rbegin()         返回一个指向map尾部的逆向迭代器
      rend()           返回一个指向map头部的逆向迭代器
      size()           返回map中元素的个数
      swap()            交换两个map
      upper_bound()     返回键值>给定元素的第一个位置
      value_comp()      返回比较元素value的函数



map的插入：

map<int,string>studentMap;

(1)studentMap.insert(pair<int,string>(1,"xiaoming"));

(2)studentMap.insert(map<int,string>::value_type(1,"xiaoming"));

(3)studentMap[1]="xiaoming";

也可以插入自己定义的对象，格式是一样的

链接1 c++数据结构学习网站《C++STL之map学习》
链接2 https://blog.youkuaiyun.com/ajianyingxiaoqinghan/article/details/78540736
https://blog.youkuaiyun.com/u014096244/article/details/39081321
https://blog.youkuaiyun.com/perfectguyipeng/article/details/73743977
V J
VJSDUT 2018 暑假集训个人练习赛2
以下题目源自 HDU POJ 代码纯属借鉴别人家的
一、Description
在ACM比赛中，你每解决一道题，你就可以获得一个气球，不同颜色的气球代表你解决了不同的问题。在WJL同学参加的一场ACM比赛中，他发现场面上有N个气球，并熟练的说出了气球的颜色。

请你编写一个程序，找出气球数量最多的颜色。
Input
有多组样例输入。

每组样例第一行输入一个整数N (0 < N <= 1000) ，代表一共有N个气球。若N=0，则代表输入结束，你不需要输出任何信息。
接下来N行每行输入一个不多于15个字母的字符串代表颜色。
Output
对于每组样例数据，在单独的一行内输出数量最多的那种颜色的气球。（数据保证输出是唯一的）
Sample Input
5
green
red
blue
red
red
3
pink
orange
pink
0
Sample Output
red
pink

#include <bits/stdc++.h>
//这是**张浩** 的代码， QAQ.....
using namespace std;

int main(){
    int n, a[1010], f, m;
    char s[1010][20], c[20];
    while(cin >> n){
        memset(a, 0, sizeof(a));
        memset(s, '\0', sizeof(s));
        if(!n)  break;
        for(int i = 0; i < n; i++){
            cin >> c;
            f = 1;
            for(int j = 0; j < i; j++){
                if(!strcmp(s[j], c)){
                    a[j]++;
                    f = 0;
                    break;
                }
            }
            if(f){
                strcpy(s[i], c);
                a[i]++;
            }
        }
        m = a[0];
        strcpy(c, s[0]);
        for(int i = 0; i < n; i++){
            if(a[i] > m){
                m = a[i];
                strcpy(c, s[i]);
            }
        }
        cout << c << endl;
    }
    return 0;
}

下面这个也是别人家的QAQ

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
using namespace std;
// 这个水题目，寡人 都不会做， 僧无可怜 啊 
int main()
{
    int n;
    char s[1020][20];
    int a[1010], t;
    while(~scanf("%d%*c",&n))
    {
        if(n == 0) break;
        int max = 0;
        for( int i = 0; i < n; i++)
        {
            gets(s[i]);
            a[i] = 0;
            for( int j = 0; j <= i; j++)
            {
                if(!strcmp(s[i], s[j]))
                      a[i]++;
            }
        }
        for( int i = 0; i < n; i++)
            {
                if(max < a[i])
                {
                    max = a[i];
                    t = i;
                }
            }
        printf("%s\n",s[t]);
    }
    return 0;
}

二、 你有身份证吗？但无论如何您一定有身份证号码。从身份证号码上可以得到每个人的具体个人信息。身份证号码有18位，其中前17位包含特殊的特殊含义：前6位代表你来自的区域，然后8位代表你的生日。其他4位代表什么？你可以百度一下。
以下是本题中可能用到的地区的代码。

在身份证号码中，可能只有33出现，0000是由其他数字取代。
这是塞缪尔的身份证号码331004198910120036你能告诉我他来自哪里吗？最初的两位表示他来自浙江省，19891012表示是他的生日日期（年/月/日）。
Input
输入包含两部分：
第一行为一个整数n，代表有n组数据
接下来为测试数据，每一行为一个代表身份证号码的字符串。
Output
根据题目描述，输出他来自哪里和他的出生日期。具体格式可以参照样例输出。
Sample Input
1
330000198910120036
Sample Output
He/She is from Zhejiang,and his/her birthday is on 10,12,1989 based on the table.
Hint
无论他是男是女，都输出He/She，不必输出特定的He或She

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <map>

using namespace std;

map<int, string> m;
// 这个水题目，寡人 haisi不会做， 僧无可怜 啊

int main()
{
    int n;
    string id;

    m[33] = "Zhejiang";
    m[82] = "Macao";
    m[11] = "Beijing";
    m[54] = "Tibet";
    m[71] = "Taiwan";
    m[21] = "Liaoning";
    m[81] = "Hong Kong";
    m[31] = "Shanghai";

    cin >> n;
    while(n--)
    {
        cin >> id;
        int region;
        region = (id[0] - '0') * 10 + (id[1] - '0');
        printf("He/She is from %s,and his/her birthday is on ", m[region].c_str());
        printf("%c%c,%c%c,%c%c%c%c",id[10],id[11],id[12],id[13],id[6],id[7],id[8],id[9]);
        printf(" based on the table.\n");
    }
    return 0;
}

3.一个数的“魔幻数字”是指它所有位数上的数之和，如果“魔幻数字”仅有一位，则被称为这个数的“究极魔幻数字”，如果“魔幻数字”有两位及两位以上，则需重复寻找“魔幻数字”的步骤，直到找到“究极魔幻数字”。

例如，对于一个正整数128，它的“魔幻数字”为11，但11有两位，所以重复之前的步骤，得到11的“魔幻数字”为2,2仅有一位数，则2是我们需要的“究极魔幻数字”。
Input
多组输入数据，每组数据为一个非负整数，若输入整数为0，说明输入结束，对该组数据不进行处理。
Output
对于每个输入的整数，在一行内输出它的“究极魔幻数字”
Sample Input
11111
128
0
Sample Output
5
2
(sum - 1) % 9 + 1为什么要先 -1 再 +1 呢，因为直接 sum%9 会出现一个问题，那就是当 n=9 时，sum=9，得到的结果为0，显而易见答案是错误的。而先 -1 之后再 +1，对最终的结果是没有影响的，又避免了9本身作为除数时的尴尬
此文源自博主xxx 他的链接 1013 Digital Roots

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <string>
#include <map>

using namespace std;
// 这个水题目，寡人 haisi不会做， 僧无可怜 啊
// 九余数定理 
int main()
{
   string n;
   while(cin >> n && n != "0")
   {
       int sum = 0;
       for( int i = 0; i < n.length(); i++)
       {
           sum += n[i] - '0';
       }
       cout << (sum - 1) % 9 + 1 << endl;
   }
    return 0;
}

4 走格子（10） 51Nod - 1344
有编号1-n的n个格子，机器人从1号格子顺序向后走，一直走到n号格子，并需要从n号格子走出去。机器人有一个初始能量，每个格子对应一个整数Ai，表示这个格子的能量值。如果Ai > 0，机器人走到这个格子能够获取Ai个能量，如果Ai < 0，走到这个格子需要消耗相应的能量，如果机器人的能量 < 0，就无法继续前进了。问机器人最少需要有多少初始能量，才能完成整个旅程。

例如：n = 5。{1，-2，-1，3，4} 最少需要2个初始能量，才能从1号走到5号格子。途中的能量变化如下3 1 0 3 7。
Input
第1行：1个数n，表示格子的数量。(1 <= n <= 50000)
第2 - n + 1行：每行1个数Ai，表示格子里的能量值(-1000000000 <= Ai <= 1000000000)
Output
输出1个数，对应从1走到n最少需要多少初始能量。
Sample Input
5
1
-2
-1
3
4
Sample Output
2
下面奉上大神代码弱菜zc

#include <iostream>
#include <bits/stdc++.h>
#include <cstdlib>
using namespace std;
// 计数， 取最小值即可。 注意数据较大
int main()
{
    int n;
    scanf("%d",&n);
    long long ans = 0, sum = 0;
    for(int i = 0; i < n; i++)
    {
        long long x;
        scanf("%lld",&x);
        sum += x;
        ans = min(ans, sum);
    }
    cout << - ans << endl;
    return 0;
}

5 1995 三子棋
小的时候大家一定玩过“井”字棋吧。也就是在九宫格中，只要任意行、列，或者任意连续对角线上面出现三个相同的，就能获胜。现在小明和小花也在玩三子棋，但是他们不是在九宫格里，而是在3×4的格子里面。现在小明先下，但是他知道小花这个人很聪明，他想知道第一步下在哪一个地方最合适，你能帮帮他吗？

Input
第一行输入一个整数T，表示数据组数（1 第二行输入两个整数x,y,表示3×4格子里面的一个坐标(x,y)（1<=x<=3,1<=y<=4）；
Output
每组数据输出最后小明输赢的结果，如果小明一定能赢，第一行输出“Win”,第二行输出小明所需要花的最少步数；如果小明跟小花只能打成平手，第一行输出“Equal”，第二行输出数字0；如果小明不能赢也不能跟小花打成平手，第一行输出“Lose”,第二行输出小花赢小明所需要花的最少步数。
Sample Input
2
2 1
2 4
Sample Output
Equal
0
Equal
0

这里写图片描述

#include <iostream>
#include <bits/stdc++.h>
#include <cstdlib>

using namespace std;
int a[5][5];

void cu()
{
     a[1][1] = 6;a[1][4] = 6;a[3][1] = 6;a[3][4] = 6;
     a[1][2] = 4 ;a[1][3] = 4 ;a[2][2] =  4;a[2][3] = 4 ;
     a[3][2] = 4 ;a[3][3] = 4 ;a[2][1] = 0 ;a[2][4] =  0;
}
int main()
{
    cu();
    int T, x, y;
    cin >> T;
    while(T--)
    {
        cin >> x >> y;
        if(a[x][y] == 0)
        {
            printf("Equal\n");
            printf("0\n");
        }
        else
        {
            printf("Win\n");
            printf("%d\n",a[x][y]);
        }
    }
    return 0;
}

6 Number SequenceHDU - 1005
一个序列

g(1) = 1, g(2) = 1, g(m) = (x * g(m - 1) + y * g(m - 2)) % 7.

现给你x, y, m, 请计算出g(m)的值。
Input
多组输入数据。每组输入数据包含3个整数x, y,和m(数据保证1 <= x, y <= 1000, 1 <= m <= 100,000,000)。若x, y, m均为0，表示输入结束，该组数据不作处理。
Output
对于每组输入数据，在一行内输出g(m) 。
Sample Input
1 1 3
1 2 10
0 0 0
Sample Output
2
5
以下附上前辈代码，转载声明原作者黄俊东

又是一道给出了运算公式的数学凡是没有优化的话，超时超内存等等是避免不了的了
这题很显然是一个找规律的题目，也就是该题的求解中是存在循环节的。对于公式 f[n] = A * f[n-1] + B * f[n-2]; 后者只有7 * 7 = 49 种可能，为什么这么说，因为对于f[n-1] 或者 f[n-2] 的取值只有 0,1,2,3,4,5,6 这7个数，A，B又是固定的，所以就只有49种可能值了。由该关系式得知每一项只与前两项发生关系，所以当连续的两项在前面出现过循环节出现了，注意循环节并不一定会是开始的 1，1 。又因为一组测试数据中f[n]只有49中可能的答案，最坏的情况是所有的情况都遇到了，那么那也会在50次运算中产生循环节。找到循环节后，就可以轻松解决了。

#include <iostream>

using namespace std;

int arr[10001];
int main()
{
     int a, b, n;
     arr[1] = arr[2] = 1;
     while(cin>> a >> b >> n, a || b || n)
     {
         int i;
         for( i = 3; i < 10001; i++)
         {
             arr[i] = (a * arr[i - 1] + b * arr[i - 2]) % 7;
             if( arr[i - 1] == 1 && arr[i] == 1)
                break;
         }
         n = n % ( i - 2);
         arr[0] = arr[i -2];
         cout << arr[n] << endl;
     }
    return 0;
}

#include <iostream>
int A,B;
int f(int n){
    if( n == 1 || n == 2){
        return 1;
    }
    return (A*f(n-1)+B*f(n-2))%7;
}
int main(){

    int n;
    while(scanf("%d%d%d",&A,&B,&n)!=EOF,A||B||n){
        int a = f(n%49);
        printf("%d\n",a);
    }
}