SDUT 天梯赛 10.15

6翻了

如果句子中有超过 3 个连续的 6，则将这串连续的 6 替换成 9；但如果有超过 9 个连续的 6，则将这串连续的 6 替换成 27。其他内容不受影响，原样输出。

从头开始遍历，如果遇到6，就计算从该数往后一共有几个6，如果满足条件就将6替换掉，否则将6输出。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <cmath>
#include <set>
#include <cstring>
#include <string>
#define ll long long
using namespace std;
const int maxn = 1e5+10;

int main()
{
    char str[1050];
    int len;
    cin.getline(str,1050);
    len = strlen(str);
    for(int i=0; i<len; i++)
    {
        if(str[i]=='6')
        {
            int num=1,flag=0;
            for(int j=i+1; j<len; j++)
            {
                if(str[j]=='6')
                {
                    num++;
                }
                else
                {
                    break;
                }
            }
            if(num>9)
            {
                flag=1;
                cout<<27;
            }
            else if(num>3)
            {
                flag=1;
                cout<<9;
            }
            i+=num-1;
            if(!flag)
            {
                for(int k=1; k<=num; k++)
                    cout<<6;
            }
        }
        else
        {
            cout<<str[i];
        }
    }
    return 0;
}

敲笨钟

对每一行诗句，判断其是否压“ong”韵。即上下两句末尾的字都是“ong”结尾。如果是压此韵的，就按题面方法糟改之后输出，输出格式同输入；否则输出 Skipped，即跳过此句。

从每句的末尾往前遍历，如果碰到’ , ‘或’ . '就判断前三个字母是否是‘ong’，如果不是则用book数组标记上，Skipped，否则去掉后三个拼音换成 qiao ben zhong。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <cmath>
#include <set>
#include <cstring>
#include <string>
#define ll long long
using namespace std;
const int maxn = 1e5+10;

int main()
{
    int n;
    char p[4];
    p[0]='g';
    p[1] = 'n';
    p[2] = 'o';
    char str[105][105];
    cin>>n;
    bool book[105];
    getchar();
    memset(book,true,sizeof(book));
    for(int i=0; i<n; i++)
        cin.getline(str[i],105);
    for(int i=0; i<n; i++)
    {
        for(int j=strlen(str[i])-1; j>=0; j--)
        {
            if(str[i][j]=='.'||str[i][j]==',')
            {
                int cnt=0,flag=1;
                for(int k=j-1; k>=j-3; k--)
                {
                    if(str[i][k]!=p[cnt])
                    {
                        flag=0;
                        break;
                    }
                    cnt++;
                }
                if(!flag)
                {
                    book[i]=false;
                    break;
                }
            }
        }
    }
    for(int i=0; i<n; i++)
    {
        if(!book[i])
            cout<<"Skipped"<<endl;
        else
        {
            int num_space=0,pos;
            for(int j=strlen(str[i])-1; j>=0; j--)
            {
                if(str[i][j]==' ')
                    num_space++;
                if(num_space==3)
                {
                    pos = j;
                    break;
                }
            }
            for(int j=0; j<pos; j++)
                cout<<str[i][j];
            cout<<" qiao ben zhong."<<endl;
        }
    }
    return 0;
}

特立独行的幸福

对一个十进制数的各位数字做一次平方和，称作一次迭代。如果一个十进制数能通过若干次迭代得到 1，就称该数为幸福数。1 是一个幸福数。此外，例如 19 经过 1 次迭代得到 82，2 次迭代后得到 68，3 次迭代后得到 100，最后得到 1。则 19 就是幸福数。显然，在一个幸福数迭代到 1 的过程中经过的数字都是幸福数，它们的幸福是依附于初始数字的。例如 82、68、100 的幸福是依附于 19 的。而一个特立独行的幸福数，是在一个有限的区间内不依附于任何其它数字的；其独立性就是依附于它的的幸福数的个数。如果这个数还是个素数，则其独立性加倍。例如 19 在区间[1, 100] 内就是一个特立独行的幸福数，其独立性为 2×4=8。

（看的别人的题解）使用了差不多算是并查集和dfs，通过dfs计算出依附的数字和判断能迭代到1，再通过并查集判断是否是依附其他数字.

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <cmath>
#include <set>
#include <stack>
#include <cstring>
#include <string>
#define ll long long
using namespace std;
const int maxn = 1e4+10;
int pre[maxn],vis[maxn],ans[maxn],f[maxn];

int solve(int n)
{
    int sum=0;
    while(n)
    {
        sum+=pow(n%10,2);
        n/=10;
    }
    return sum;
}

void dfs(int cur,int s,int n)
{
    if(vis[n])
        return;
    if(n==1)
    {
        ans[s]=cur;
        return;
    }
    vis[n]=1;
    f[pre[n]]=n;
    dfs(cur+1,s,pre[n]);
}

bool judge(int n)
{
    if(n==1||n==0)
        return false;
    for(int i=2; i<=sqrt(n); i++)
    {
        if(n%i==0)
            return false;
    }
    return true;
}

int main()
{
    ios::sync_with_stdio(false);
    int l,r;
    for(int i=2; i<=maxn; i++)
        pre[i] = solve(i);
    for(int i=1; i<=maxn; i++)
        f[i]=i;
    cin>>l>>r;
    for(int i=l; i<=r; i++)
    {
        memset(vis,0,sizeof(vis));
        dfs(0,i,i);
    }
    int flag=0;
    for(int i=l; i<=r; i++)
    {
        if(ans[i]&&f[i]==i)
        {
            flag=1;
            if(judge(i))
                cout<<i<<' '<<ans[i]*2<<endl;
            else
            {
                cout<<i<<' '<<ans[i]<<endl;
            }
        }
    }
    if(!flag)
        cout<<"SAD"<<endl;
    return 0;
}

深入虎穴

著名的王牌间谍 007 需要执行一次任务，获取敌方的机密情报。已知情报藏在一个地下迷宫里，迷宫只有一个入口，里面有很多条通路，每条路通向一扇门。每一扇门背后或者是一个房间，或者又有很多条路，同样是每条路通向一扇门…… 他的手里有一张表格，是其他间谍帮他收集到的情报，他们记下了每扇门的编号，以及这扇门背后的每一条通路所到达的门的编号。007 发现不存在两条路通向同一扇门。找到离入口最远的门。

有个小坑就是找出入口的编号，比赛时我默认为 1 就是入口，结果…
遍历一边所有编号,入度为0的就是入口.

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <cmath>
#include <set>
#include <cstring>
#include <string>
#define ll long long
using namespace std;
const int maxn = 1e5+10;
int n,k;
vector<int>g[maxn];
int vis[maxn];
int max_len,num;

void dfs(int p,int deep)
{
    for(int i=0; i<g[p].size(); i++)
    {
        deep++;
        dfs(g[p][i],deep);
        deep--;
    }
    if(deep>max_len)
    {
        max_len = deep;
        num = p;
    }
}

int main()
{
    int u;
    cin>>n;
    for(int i=1; i<=n; i++)
    {
        cin>>k;
        for(int j=1; j<=k; j++)
        {
            cin>>u;
            g[i].push_back(u);
            vis[u] = 1;
        }
    }
    int start;
    max_len=-1;
    for(int i=1; i<=n; i++)
    {
        if(!vis[i])
        {
            start=i;
            break;
        }
    }
    dfs(start,0);
    cout<<num<<endl;
    return 0;
}

彩虹瓶
题目链接

存在货架上的货物用栈来存储,当时用的stl里的stack,但是不输出结果,还是不太熟,最后手写栈…在这道题上浪费很多时间…
最后判断货物最顶端的编号是否是n,如果是就输出YES,否则输出NO,在往栈里存货物时,注意是否超过货架的存储容量.

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <cmath>
#include <set>
#include <stack>
#include <cstring>
#include <string>
#define ll long long
using namespace std;
const int maxn = 1e5+10;

int main()
{
    ios::sync_with_stdio(false);
    int n,m,k;
    int in[1050];
//    stack<int>s;
    vector<int>ans;
    cin>>n>>m>>k;
    int s[1050];
    while(k--)
    {
        int top=-1,tail=-1;
        for(int i=1; i<=n; i++)
            cin>>in[i];
        int now=1;
        for(int i=1; i<=n; i++)
        {
            if(in[i]!=now)
            {
                if(tail!=top)
                {
                    int t = s[tail];
                    while(t==now&&tail!=top)
                    {
                        now++;
                        ans.push_back(t);
                        tail--;
                        if(tail!=top)
                            t = s[tail];
                    }
                }
                if((tail-top)<m)
//                    s.push(in[i]);
                    s[++tail] = in[i];
            }
            else
            {
                ans.push_back(now);
                now++;
            }
            int t = s[tail];
            while(t==now&&!tail!=top)
            {
                now++;
                ans.push_back(t);
                tail--;
                if(tail!=top)
                    t=s[tail];
            }
        }
        int len = ans.size()-1;
        if(ans[len]==n)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}