UVa第五章STL应用 习题（（解题报告））详细！

例题5——9 数据库 Database UVa 1592

<strong><span style="font-size:18px;"><span style="font-size:18px;"><strong><span style="font-size:18px;">#include<iostream>
#include<string>
#include<stdio.h>
#include<map>
using namespace std;
int cnt[10042][12];
int n,m;

void before()//此函数把每个格子里的字符串都映射成数字
{
    int x=0;
    char ch;
    getchar();  //  吃掉主函数中的空行
    string str;
    map<string,int>dict;
    int t;
    for(int i=0; i<n; i++)
    {
        t=0;//用t来表示列数
        for(;;)
        {</span></strong>
<strong><span style="font-size:18px;">             ch=cin.get();       //  每次读取一个字符
            if(ch!=','&&ch!='\n')
                str+=ch;        // string类 重载了对于char 也可以相加的=号
            else
            {
                if(dict.count(str))      //  在map中检查是否出现过，如果出现过就用原来数字初始化此格子
                {
                    cnt[i][t++]=dict[str];

                }
                else
                {
                    dict[str]=++x;
                    cnt[i][t++]=dict[str];
                }
                str.clear();       //对于每一行勿忘str。clear（）
            }
            if(ch=='\n')
            {
                break;
            }
        }
    }
}

int main()
{
    while(cin>>n>>m)
    {
        before();
        string str;
        int flag=0;
        for(int i=0; i<m-1; i++)
        {                             //最外层两个for循环控制列变换，枚举任一特定的两列，用第三个for循环检测每行和列数交叉的数字二元组是否
            for(int j=i+1; j<m; j++) // 出现过。
            {
                map< pair<int,int> ,int >buf;
                for(int k=0; k<n; k++)
                {
                    pair<int,int>pq(cnt[k][i],cnt[k][j]);
                    if(buf.count(pq))
                    {
                        flag=1;
                        cout<<"NO"<<endl
                            <<buf[pq]+1<<" "<<k+1<<endl
                            <<i+1<<" "<<j+1<<endl;

                        break;
                    }
                    else
                        buf[pq]=k;
                }
                if(flag)
                    break;
            }
            if(flag)
                break;
        }
        if(!flag)
            cout<<"YES"<<endl;
    }
    return 0;
}
</span></strong></span></span></strong>

习题5-1 代码对齐 UVa 1593 Alignment of Code

<strong><span style="font-size:18px;"><span style="font-size:18px;"><span style="font-size:18px;"><strong>#include<iostream>
#include<string>
#include<stdio.h>
#include<vector>
#include<sstream>
using namespace std;
int main()
{
    vector<string>cnt[1003];
    string str;
    int row=0;
    int M[20]= {0};
    while(getline(cin,str))
    {
        stringstream ss(str); //stringstream 以空格和换行作为分隔符
        string buf;
        int col=0;//控制列数

        while(ss>>buf)
        {
            cnt[row].push_back(buf);  //然后利用ss 可以把一行元素扯开，push到每一行中去。
            M[col]=max((int)buf.size(),M[col]);//每循环一次列数加一，那么n行输入之后每个M元素
            col++;                  // 值即为此列最长字符值。
        }
        row++;      //行数加一
        ss.clear();     // 如果多次使用ss对象，尽量clear一下。
    }
    int j ,i;
    for( i=0; i<row; i++)
    {
        for( j=0; j<cnt[i].size()-1; j++)
        {
            cout<<cnt[i][j];

            for(int k=0; k<=M[j]-cnt[i][j].size(); k++)
                cout<<" ";
        }
        cout<<cnt[i][j]<<endl;
    }
    return 0;
}</strong>
</span></span></span></strong>

习题5-2 Ducci Sequence UVa1594

说实话 这个题目挺气人！！主要还是智商问题啊 。一开始很单纯的想，对于每个多元组的生成，判断是否出现过和是否是0元组。那么想着利用stringstrem 把输入 输出到数组，运算完之后，在运用stringstream 生成一个string对象放入map ，所以说不超时才怪！但是还是想把这个过程模拟一遍。至今有一处特别奇妙，对于多次运用stringstream，clear（）函数怎么无效！！！不过还是在不断调试中学到了好多东西

接下来是一个严重超时的版本：

<strong><span style="font-size:18px;"><span style="font-size:18px;"><strong><span style="font-size:18px;">#include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<map>
#include<sstream>
using namespace std;
int main()
{
    int t,n;
    (cin>>t).get();

    while(t--)
    {
        map<string,int>cnt;
        (cin>>n).get();
        string str;
        getline(cin,str);
        cnt[str]=1;

        stringstream ss;
        ss.str(str);
        for(;;)
        {
            int dict[16],t=0;
            while(ss>>dict[t])
            {
                t++;
            }

            string stream,sumstr;
            ss.clear();
            int k=dict[0],flag=1;

            for(int i=0; i<n-1; i++)
            {
                stringstream ss;
                dict[i]=abs(dict[i]-dict[i+1]);
                if(dict[i]!=0)
                    flag=0;
                ss<<dict[i];
                ss>>stream;

                sumstr+=(stream+" ");
                ss.clear();
            }
            dict[t-1]=abs(dict[t-1]-k);

            if(dict[t-1]!=0)
                flag=0;
            if(flag)
            {
                cout<<"ZERO"<<endl;
                break;
            }

            stringstream sss;

            sss<<dict[t-1];
            sss>>stream;
            sumstr+=stream;

            if(cnt.count(sumstr))
            {
                cout<<"LOOP"<<endl;
                break;
            }
            cnt[sumstr]=1;
            ss.clear();
            ss.str(sumstr);
        }
        cnt.clear();
    }
    return 0;
}
/*
4
4
8 11 2 7
**/

</span></strong></span></span></strong>

然后baidu一下网上代码，只看了一句话就恍然大悟！！说是在生成1000次之内必然出现结果！那么只需在循环1000次中判断是否出现0元组，如果出现break，一千次之内没出现，那么必然存在loop了，这样就不用保存每次的生成结果了！！

<strong><span style="font-size:18px;"><span style="font-size:18px;"><strong><span style="font-size:18px;">#include<iostream>
#include<string.h>
#include<cmath>
using namespace std;
int main()
{
    int t,cnt[23];
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        int i;

        for(i=0; i<n; i++)
        {
            cin>>cnt[i];

        }
        int k,ok=0;
        for(int j=0; j<1001; j++)
        {
            int T=cnt[0],flag=1;
            for(k=0; k<i-1; k++)
            {
                cnt[k]=abs(cnt[k]-cnt[k+1]);
                if(cnt[k]!=0)
                    flag=0;
            }
            cnt[k]=abs(cnt[k]-T);
            if(cnt[k]!=0)
                flag=0;
            if(flag)
            {
                ok=1;
                cout<<"ZERO"<<endl;
                break;
            }

        }
        if(!ok)
            cout<<"LOOP"<<endl;

    }
    return 0;
}
</span></strong></span></span></strong>

之开始真是日了狗了，还算注意到了输入为1的时候。这个时候什么都不输出。但是一开始就是“Discarded cards： ”非多了一个空行，导致输入为1的时候也输出多一个空行，PE N次！

<strong><span style="font-size:18px;"><span style="font-size:18px;"><strong><span style="font-size:18px;">#include<iostream>
#include<queue>
using namespace std;
int main()
{
    int n;
    while(cin>>n,n)
    {
        queue<int>cnt;
        for(int i=1;i<=n;i++)
        {
            cnt.push(i);
        }
        int flag=1;
        cout<<"Discarded cards:";

        while(cnt.size()!=1)
        {
            if(flag)
                {
                    flag=0;
                    cout<<" "<<cnt.front();
                }
                else
            cout<<", "<<cnt.front();
            cnt.pop();
            cnt.push(cnt.front());
            cnt.pop();
        }

        cout<<endl<<"Remaining card: "<<cnt.front()<<endl;
    }
    return 0;
}
</span></strong></span></span></strong>

 习题 5-4 Foreign Exchange UVa 10763

自己还真不会做！哭死…看来水题刷的少~，有两种方法，第一种特别逗比~，第二种不失为好方法，值得学习。

<strong><span style="font-size:18px;"><span style="font-size:18px;"><strong><span style="font-size:18px;">#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    int n;
    while(cin>>n,n)
    {
        vector<int>cnt[2];
        int a,b;
        for(int i=0;i<n;i++)
        {
            cin>>a>>b;
            cnt[0].push_back(a);
            cnt[1].push_back(b);
        }
        sort(cnt[0].begin(),cnt[0].end());
        sort(cnt[1].begin(),cnt[1].end());
        if(cnt[0]==cnt[1])
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;

    }
    return 0;
}
</span></strong></span></span></strong>

TWO：

<strong><span style="font-size:18px;"><span style="font-size:18px;"><strong><span style="font-size:18px;">#include<iostream>
#include<string.h>
using namespace std;
int graph[2000][2000];
int main()
{
    int n;
    while(cin>>n,n)
    {
        int a,b;
        memset(graph,0,sizeof(graph));
        for(int i=0;i<n;i++)
        {
            cin>>a>>b;
            graph[a][b]++;
            graph[b][a]--;
        }
        int ok=0;
        for(int i=0;i<2000;i++)
        {
            for(int j=0;j<2000;j++)
            {
                if(graph[i][j]!=0)
                    {
                        ok=1;
                        goto loop;
                    }
            }
        }
      loop:
          if(ok)
          cout<<"NO"<<endl;
      if(!ok)
        cout<<"YES"<<endl;
    }
}
</span></strong></span></span></strong>

Compound Words UVA 10391 习题 5-5

<strong><span style="font-size:18px;"><span style="font-size:18px;"><strong><span style="font-size:18px;">#include<iostream>
#include<set>
#include<string>
using namespace std;
int main()
{
    string str;
    set<string>cnt;
    while(cin>>str)
        cnt.insert(str);
   set<string>::iterator it;
   for(it=cnt.begin();it!=cnt.end();it++)
   {
       for(int i=0;i<(*it).size()-1;i++)
       {
           string str1=(*it).substr(0,i+1);
           string str2=(*it).substr(i+1,(*it).size()-i-1);
           if(cnt.count(str1)&&cnt.count(str2))
           {
               cout<<*it<<endl;
               break;
           }
       }
   }</span></strong></span></span></strong>
<strong><span style="font-size:18px;"><span style="font-size:18px;"><strong><span style="font-size:18px;">return 0;
}
</span></strong></span></span></strong>

习题5-6 Symmetry Seoul UVa 1595 

其实更多的是学习了stl的用法，注意代码运用了类复制构造函数，用产生的临时对象作为函数参数。

<strong><span style="font-size:18px;"><span style="font-size:18px;">#include<set>
#include<iostream>
using  namespace std;
int main()
{
    int t,n;
    cin>>t;
    while(t--)
    {
        set< pair<double ,double> >cnt;
        typedef pair<double,double>Point;
        cin>>n;
        double sum=0;
        for(int i=0; i<n; i++)
        {
            double x,y;
            cin>>x>>y;
            sum+=x;
            cnt.insert(Point(x,y));
        }
        double aver=sum/n;//cout<<"aver="<<aver<<endl;
        bool ok=true;
        for(set< pair<double,double> >::iterator it=cnt.begin(); it!=cnt.end(); it++)
        {
            if(!cnt.count(Point(2*aver-(*it).first,(*it).second)))
            {
                //cout<<2*aver-(*it).first<<" "<<(*it).second<<endl;
                ok=false;
                break;
            }
        }
        if(ok)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}
</span></span></strong>

 习题5-7 Printer Queue UVa 12100

题目有一处想当麻烦，直接导致了优先队列不是那么可取。那就是最后一组测试样例。那么要模拟队列运作了。看了下网上思路。队列中每个元素都有两个属性，一个是紧急性，一个是是否是要打印。每个元素都可以设成类对象。同时用一个优先队列保存紧急性属性，对于每个优先队列队首元素，都是接下来要应该打印的元素，那么对于每次对象P的弹出，判断是不是应该打印的元素，如果是接下来还要判断是不是之前m值所要求打印的元素，如果是那么就该出现结果了，即优先队列弹出的元素总数，不是的话移到末尾，同时都要pop（）。

 

<strong><span style="font-size:18px;">#include<iostream>
#include<queue>
using namespace std;

struct P
{
    int prio,IF;
    P(int x,int y)
    {
        prio=x;
        IF=y;
    }
};
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        priority_queue<int>dict;
        queue<P>cnt;
        int n,m;
        cin>>n>>m;
        for(int i=0; i<n; i++)
        {
            int a;
            cin>>a;
            if(i!=m)
                cnt.push(P(a,1));
            else
                cnt.push(P(a,0));
            dict.push(a);
        }

        int count=0,ok=0;
        for(;;)
        {
            int t=dict.top();
            dict.pop();
            while(1)
            {
                P x=cnt.front();

                cnt.pop();
                if(t==x.prio)
                {
                    count++;
                    if(x.IF!=0)
                    {

                        break;
                    }
                    else
                    {
                        ok=1;
                        cout<<count<<endl;
                        break;
                    }
                }
                else
                {
                    cnt.push(x);
                }
            }
            if(ok)
                break;
        }
    }
    return 0;
}
</span></strong>

后半部分后续！！！！

时间： 2024-10-13 19:54:12

UVa第五章STL应用 习题（（解题报告））详细！的相关文章

《Python核心编程》 第五章 数字 - 课后习题

课后习题  5-1 整形. 讲讲 Python 普通整型和长整型的区别. 答:普通整型是绝大多数现代系统都能识别的. Python的长整型类型能表达的数值仅仅与你机器支持的(虚拟)内存大小有关. 5-2 运算符 (a) 写一个函数,计算并返回两个数的乘积 (b) 写一段代码调用这个函数,并显示它的结果 答: def pro(a,b): p = a*b return p a = int(raw_input("a=")) b = int(raw_input("b="))

STL学习笔记（第五章 STL组件）

STL组件 若干精心勾画的组件共同合作,构筑起STL的基础.这些组件最关键的是容器.迭代器和算法. 下图演示了STL组件之间的合作 容器(Containers) 容器类别(简称容器)用来管理一组元素.为了适应不同需求,STL提供了不同类型的容器. 总的来说,容器可分为两类: 1.序列式容器Sequence containers,此乃可序群集,其中每个元素均有固定位置(取决于插入时机和地点,和元素值无关). STL提供三个定义好的序列式容器:vector.deque和list. 2.关联式容器As

第十五章 面向对象程序设计 习题

15.3 1 class Quote 2 { 3 public 4 Quote()=default; 5 Quote(const std::string &book,double sales_price):bookNo(book), 6 price(sales_price){};//类的初始化 7 8 std::string isbn() const {return bookNo;} 9 10 virtual double net_price(std::size_t n) const 11 {r

【算法导论第五章】课后习题解析

---恢复内容开始--- 5.1-1证明:假设在程序HIRE-ASSISTANT的第4行中,我们总是能够决定哪一个应聘者最佳,则意味着我们知道应聘者排名的总次序 既然我们总是能够决定哪一个应聘者最佳,想必我们已经对应聘者进行比较了,既然已经进行比较,排序就不应是个问题,既然可以进行排序,总次序也就可以知道了 5.1-2描述RANDOM(a,b)过程的一种实现,它只调用RANDOM(0,1).作为a和b的函数,你的程序的期望运行时间是多少? 没看懂,不会做 5.2-1 分析: 由5.1节中概率分析

《Python编程：从入门到实践》第五章 if语句 习题答案

#5.1 major = 'Software Engineering' print("Is major =='Software Engineering'? I predict True.") print(major=='Software Engineering') print("Is major =='Software Engineering'? I predict False.") print(major=='Computer Science') #5.2 pri

《学习Opencv》第五章 习题6

这是第五章 习题5.6的结合版,其中实现了摄像头抓拍功能,能够成功运行. #include "stdafx.h" #include "cv.h" #include "highgui.h" void* getImage() { CvCapture* capture=cvCreateCameraCapture(0); IplImage *img1=NULL,*img2=NULL,*img3=NULL,*frame=NULL,*ppImage=NULL

Python核心编程（第二版） 第五章习题答案

5-1.整型.讲讲Python普通整型和长整型的区别. 答:Python 的标准整数类型是最通用的数字类型.在大多数 32 位机器上,标准整数类型的取值范围是-2**31到 2**31-1,也就是-2,147,483,648 到 2,147,483,647.如果在 64 位机器上使用 64 位编译器编译 Python,那么在这个系统上的整数将是 64 位. Python 的长整数类型能表达的数值仅仅与你的机器支持的(虚拟)内存大小有关. 5-2.操作符.(a)写一个函数,计算并返回两个数的乘积.

Python核心编程第五章习题

Python核心编程-第五章-习题 5.1  整形,讲讲Python普通整形与长整形的区别? Python的标准整形类型是最通用的数字类型.在大多数32位机器上,标准整形类型的取值范围是-2**32-2**32 - 1. Python的长整型类型能表达的数值仅仅与你的机器支持的(虚拟)内存大小有关,换句话说,Python能轻松表达很大的整数. 长整型类型是标准整形类型的超集,当程序需要使用比标准整形更大的整型时,可以使用长整型类型,在整型值后面添加L,表示这个为长整型,3.0版本已经统一称为为整

C++ Primer【第五版】习题参考答案——第五章（语句）

#include <iostream> #include <vector> #include <string> using namespace std; /******************************************************************* Ex_5_1: 空语句就是只含有一个分号的语句. 如果在程序的某个地方,语法上要求有一条语句,但是逻辑上不需要, 这时就需要一条空语句. Ex_5_2: 块就是由花括号包围的复合语句