2017-5 校内练习1 解题报告

这次校内练习一共有6道题目，安排了一天时间来做。

虽然都做出来了，但是因为本身题目都不大难，而且自己也做了老长时间，感觉还是差了好多，尤其是编码的准确度方面。还有就是对题意的理解还是有点慢，这个也是个问题。

下面就简单说一下我对于这六道题目的解法，不一定是最好的，如果有更好的欢迎指出。

A题 放苹果

题目描述

把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。

输入

第一行是测试数据的数目t（0 <= t <= 20）。以下每行均包含二个整数M和N，以空格分开。1<=M，N<=10。

输出

对输入的每组数据M和N，用一行输出相应的K。

样例输入

1
7 3

样例输出

8

这个题我纠结了好长时间，也没想到什么好办法。也就是穷举法来做。穷举的时候，要考虑去重，这个操作起来就比较复杂了。一开始我想的是穷举每个盘子的可能情况，然后用数组保存这些情况，下次再求的时候判断是不是已经存在了。用STL的set很容易做到判断是否重复，但是很明显超时的。后来想到可以依次从第一个盘子开始枚举，而其他n-1个盘子为了避免重复，必然要小于等于他，就构造了下面所示的这个递归程序了。跑了4ms，有点慢，感觉是这个算法不是理想的，但是别的也真想不出来了。（p.s.我一开始用枚举所有组合然后去重写了个龟速版，把所有答案都打出来了。事实是这个题数据量太小，直接打表也是能过的）

我的解答如下：

#include<cstdio>
using namespace std;
int cnt;
int sum;
void g(int m, int n, int s)
{
    if (n == 0)
    {
        if (s == sum)
            cnt++;
        return;
    }
    for (int i = m; i >= 0; i--)
    {
        g(i, n - 1, s + i);
    }
}
int solve(int m,int n)
{
    cnt = 0;
    sum = m;
    g(m, n, 0);
    return cnt;
}
int main()
{
    int a, b, t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d %d", &a, &b);
        printf("%d
", solve(a, b));
    }
    return 0;
}

B题 Optimal Parking

题目描述

When shopping on Long Street, Michael usually parks his car at some random location, and then walks to the stores he needs. Can you help Michael choose a place to park which minimises the distance he needs to walk on his shopping round? Long Street is a straight line, where all positions are integer. You pay for parking in a specific slot, which is an integer position on Long Street. Michael does not want to pay for more than one parking though. He is very strong, and does not mind carrying all the bags around.

输入

The first line of input gives the number of test cases, 1 ≤ t ≤ 100. There are two lines for each test case. The first gives the number of stores Michael wants to visit, 1 ≤ n ≤ 20, and the second gives their n integer positions on Long Street, 0 ≤ xi ≤ 99.

输出

Output for each test case a line with the minimal distance Michael must walk given optimal parking.

样例输入

2
4
24 13 89 37
6
7 30 41 14 39 42

样例输出

152
70

这个题也是有点坑的，一开始题目意思理解错了。我以为去完一个店就得吧东西放回车上，结果跟样例怎么都对不上。蛋疼了好长时间才发现，这货居然能带着重量级的东西直接去下一家店。不过我觉得就算拿得下拿一大堆别的东西去店里也不大好吧，寄存也不一定放得下。。。扯远了。所以说这个题坑点在于和常识不一致。理解了题意，只要找到最大值和最小值就可以了。我用了个排序，$O(nlogn)$的时间，其实用两趟遍历找最大和最小的$O(n)$是更好的，STL好像也有相关函数吧。不过数据量不大，无所谓了。

#include<cstdio>
#include<algorithm>
using namespace std;
int a[105];
int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        int n;
        scanf("%d", &n);
        int i, j;
        for (i = 0; i < n; i++)
        {
            scanf("%d", &a[i]);
        }
        sort(a, a + n);
        printf("%d
", (a[n - 1] - a[0]) * 2);
    }
    return 0;
}

C题 Cow Multiplication

题目描述

Bessie is tired of multiplying pairs of numbers the usual way, so she invented her own style of multiplication. In her style, $A×B$ is equal to the sum of all possible pairwise products between the digits of $A$ and $B$. For example, the product $123×45$ is equal to $1×4 + 1×5 + 2×4 + 2×5 + 3×4 + 3×5 = 54$. Given two integers $A$ and $B$ ($1<A,B ≤ 10^9$), determine $A×B$ in Bessie's style of multiplication.

输入

The first line of input gives the number of test cases, $1 ≤ t ≤ 100$. Each test case contains two integers A and B.

输出

Output for each test case a line with the $A×B$ in Bessie's style of multiplication.

样例输入

2
123 45
1 12

样例输出

54
3

这道题是全场最水，直接把每一位拆开相乘加一下就行。直接用字符串做，非常简单。

#include<cstdio>
using namespace std;
char str1[100], str2[100];
int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        long long int sum = 0;
        scanf("%s %s", str1, str2);
        for(int i=0;str1[i]!=0;i++)
            for (int j = 0; str2[j] != 0; j++)
            {
                //printf("%d * %d
", str1[i] - '0', str2[j] - '0');
                sum += (str1[i] - '0')*(str2[j] - '0');
            }
        printf("%lld
", sum);
    }
    return 0;
}

D题 求高精度幂

题目描述

对数值很大、精度很高的数进行高精度计算是一类十分常见的问题。比如，对国债进行计算就是属于这类问题。

现在要你解决的问题是：对一个实数$R$( $0.0 < R < 99.999$ )，要求写程序精确计算 $R$ 的 $n$ 次方($R^n$)，其中$n $是整数并且 $0＜n≤25$。

输入

输入包括多组 $R$ 和 $n$。 $R$ 的值占第 1 到第 6 列，$n$ 的值占第 8 和第 9 列。

输出

对于每组输入，要求输出一行，该行包含精确的 $R$ 的 $n$ 次方。输出需要去掉前导的 0 后不要的 0 。如果输出是整数，不要输出小数点。

样例输入

95.123 12
0.4321 20
5.1234 15
6.7592  9
98.999 10
1.0100 12

样例输出

548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201

这个题是浮点高精度，其实是在整数高精度的基础上做就可以了。首先将小数点去掉，看成高精度整数相乘，然后根据小数点的位置（$p$个$n$位小数相乘，小数位有$pn$位，包括末尾的零），补上小数点和去除前导零和末尾零就行了。就是写起来非常麻烦。有用Java过的，只要400多个Byte的代码。顺便提一下求幂可以用快速幂算法，$O(logn)$的时间。

#include<iostream>
#include<string>
using namespace std;
string add(string n1, string n2)
{
    string t, ans;
    int i, j;
    if (n1.length() > n2.length())
    {
        t.append(n1.length() - n2.length(), '0');
        n2 = t + n2;
    }
    else if (n1.length() < n2.length())
    {
        t.append(n2.length() - n1.length(), '0');
        n1 = t + n1;
    }
    t.clear();
    int carry = 0;
    for (i = n1.length() - 1; i >= 0; i--)
    {
        t = (((n1[i] - '0') + (n2[i] - '0') + carry) % 10) + '0';
        carry = ((n1[i] - '0') + (n2[i] - '0') + carry) / 10;
        ans = t + ans;
    }
    if (carry) ans = '1' + ans;
    return ans;
}
string imul(string a, string b)
{
    string tmp, t;
    string sum = "0";
    if (a.length() < b.length())
        swap(a, b);
    int carry = 0;
    int offset = 0;
    for (int i = b.length() - 1; i >= 0; i--)
    {
        tmp.clear();
        carry = 0;
        for (int j = a.length() - 1; j >= 0; j--)
        {
            t = (((b[i] - '0')*(a[j] - '0') + carry) % 10) + '0';
            carry = ((b[i] - '0')*(a[j] - '0') + carry) / 10;
            tmp = t + tmp;
        }
        if (carry > 0)
        {
            t = carry + '0';
            tmp = t + tmp;
        }
        if (offset)tmp.append(offset, '0');
        offset++;
        sum = add(sum, tmp);
    }
    return sum;
}
string power(string base, int n)
{
    string result = "1";
    while (n != 0)
    {
        if (n & 1) result = imul(result, base);
        base = imul(base, base);
        n /= 2;
    }
    return result;
}
string solve(string base, int n)
{
    int dotp = base.find('.');
    int fltcnt = base.size() - dotp - 1;
    string base2;
    int i;
    for (i = 0; i < base.length(); i++)
        if (base[i] != '.')base2.push_back(base[i]);
    string powresult = power(base2, n), ansi, ansf, ans;
    bool flag = false;
    for (i = 0; i < powresult.length() - fltcnt*n; i++)
    {
        if (powresult[i] != '0' || flag)
        {
            ansi.push_back(powresult[i]);
            flag = true;
        }
    }
    ansi.push_back('.');
    flag = false;
    for (i = 0; i < n*fltcnt; i++)
    {
        if (powresult[powresult.length() - 1 - i] != '0' || flag)
        {
            ansf = powresult[powresult.length() - 1 - i] + ansf;
            flag = true;
        }
    }
    return ansi + ansf;
}
int main()
{
    ios::sync_with_stdio(false);
    string s;
    int n;
    while (cin >> s)
    {
        cin >> n;
        cout << solve(s, n) << endl;
    }
    return 0;
}

E题

题目描述

You have just moved from Waterloo to a big city. The people here speak an incomprehensible dialect of a foreign language. Fortunately, you have a dictionary to help you understand them.

输入

Input consists of up to 100,000 dictionary entries, followed by a blank line, followed by a message of up to 100,000 words. Each dictionary entry is a line containing an English word, followed by a space and a foreign language word. No foreign word appears more than once in the dictionary. The message is a sequence of words in the foreign language, one word on each line. Each word in the input is a sequence of at most 10 lowercase letters.

输出

Output is the message translated to English, one word per line. Foreign words not in the dictionary should be translated as "eh".

样例输入

dog ogday
cat atcay
pig igpay
froot ootfray
loops oopslay

atcay
ittenkay
oopslay

样例输出

cat
eh
loops

提示

Huge input and output,scanf and printf are recommended.

这个题是求两个字符串的对应。最容易想到的是使用STL的map容器，但是很明显，这题这样做会超时。map底层是红黑树实现的，其worst-case时间复杂度虽然也能保证为$O(logn)$，但是这个题数据量很大，而且STL本身也很慢。考虑$O(1)$的数据结构，可以使用哈希表和前缀树。我这里使用前缀树做的。其实这道题之前在vjudge也刷过，用的就是哈希表。哈希表最常见的方法是拉链法，我当时用的是STL的vector来代替链表。那边的服务器应该是开了O2优化的，435ms完美AC。但是学校的服务器没开O2，STL就是各种坑点了，用STL实现的哈希表就是过不了。我特地把我这个AC掉的用vjudge那边的又跑了一遍，需要200多ms，学校的服务器只需要100ms。可惜学校的服务器用那个vector的哈希表在没开O2的情况3000ms都不够，真是无语。

后来在做前缀树的时候，用string类解析输入、传参，和动态内存分配依然过不了。最后不得已，用了传统的C-style的字符串和开大数组的方法，才过了。另外这题还有一个坑点，就是输入处理。gets()读取到的空行第一个字符是' '。用这个作为标志就行了。

#include<iostream>
#include<cstdlib>
#include<cstring>
#include<string>
using namespace std;
struct node
{
    bool isword;
    char translated[15];
    node * childs[26];
    node()
    {
        isword = false;
    }
};
node * trie;
size_t top;
node pool[150005];
inline node * newnode()
{
    return &pool[top++];
}
void addword(const char * src , char * dst)
{
    node * pn = trie;
    int i;
    for (i = 0; src[i] != 0; i++)
        if (pn->childs[src[i] - 'a'])
        {
            pn = pn->childs[src[i] - 'a'];
        }
        else
        {
            pn->childs[src[i] - 'a'] = newnode();
            pn = pn->childs[src[i] - 'a'];
        }
    pn->isword = true;
    strcpy(pn->translated, dst);
}
char * findword(const char * src)
{
    node * pn = trie;
    int i;
    for (i = 0; src[i] != 0; i++)
        if (pn->childs[src[i] - 'a'] != NULL)
            pn = pn->childs[src[i] - 'a'];
        else
            return "eh";
    return pn->translated;
}
int main()
{
    char buf[256];
    char dst[15], src[15];
    trie = newnode();
    for (;;)
    {
        fgets(buf, 255, stdin);
        if (buf[0] == '
')
            break;
        sscanf(buf, "%s %s", dst, src);
        addword(src, dst);
    }
    while (scanf("%s", buf) != EOF)
        puts(findword(buf));
    return 0;
}

之前的哈希表实现也附上吧

#include<iostream>
#include<vector>
#include<map> 
#include<string>
using namespace std;
vector<pair<string,string> > hashtbl[99991];
unsigned hashfunc(string & s)
{
    int i;
    unsigned hshval=0;
    for(i=0;i<s.length();i++)
        hshval=(hshval<<5)+s[i];
    return hshval%99991;
}
int main() {
    std::ios::sync_with_stdio(false);
    string tmpline;
    for(;;)
    {
        getline(cin,tmpline);
        if(tmpline=="")break;
        int p=tmpline.find(' ');
        pair<string,string> pr;
        pr.first=tmpline.substr(0,p);
        pr.second=tmpline.substr(p+1,tmpline.length()-p-1);
        hashtbl[hashfunc(pr.second)].push_back(pr);
    }
    while(cin>>tmpline)
    {
        int i;
        bool flag=false;
        unsigned hsv=hashfunc(tmpline);
        for(i=0;i<hashtbl[hsv].size();i++)
        {
            if(hashtbl[hsv][i].second==tmpline)
            {
                cout<<hashtbl[hsv][i].first<<endl;
                flag=true;
            }
        }
        if(!flag)cout<<"eh"<<endl; 
    }
    return 0;
}

F题 Pots

题目描述

You are given two pots, having the volume of $A$ and $B$ liters respectively. The following operations can be performed:

FILL($i$)      fill the pot i ($1 ≤ i ≤ 2$) from the tap;

DROP($i$)     empty the pot $i$ to the drain;

POUR($i$,$j$)    pour from pot $i$ to pot $j$; after this operation either the pot $j$ is full (and there may be some water left in the pot $i$), or the pot $i$ is empty (and all its contents have been moved to the pot $j$).

Write a program to find the shortest possible sequence of these operations that will yield exactly $C$ liters of water in one of the pots.

输入

On the first and only line are the numbers $A,B$, and $C$. These are all integers in the range from $1$ to $100$ and $C≤max(A,B)$.

输出

The first line of the output must contain the length of the sequence of operations $K$. The following $K$ lines must each describe one operation. If there are several sequences of minimal length, output any one of them. If the desired result can’t be achieved, the first and only line of the file must contain the word ‘impossible’.

样例输入

3 5 4

样例输出

6
FILL(2)
POUR(2,1)
DROP(1)
POUR(2,1)
FILL(2)
POUR(2,1)

这个题是隐式图问题，之前做过杭电的一道电梯题，跟这个相类似。

两个杯子的水来回倒，或者去接水，或者去倒掉；也就是说，在每一步有四个状态的转换。而在具体的处理上，两个杯子相互倒的时候，还要考虑到A倒到B中，B是满了还是没满。因此把整个问题看作图，两个杯子的水的容量构成的二元组看作是顶点，具体的状态转换（倒掉A，倒掉B，接满A，接满B，A倒到B，B倒到A）看作是边，用BFS就可以做了。对于要追踪BFS，《算法导论》书中提到是构建搜索树的方法，增加前驱顶点的指针就可以了，这样搜索到结尾，只需要往回找，就能把整个路径输出了。

#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
#include<set>
#include<string>
using namespace std;
int gp[105][105] = { 0 };
struct mypair
{
    int first;
    int second;
    string command;
    mypair * father;
    mypair(int f, int s, char * c,mypair * fh)
    {
        first = f;
        second = s;
        command = c;
        father = fh;
    }
    mypair()
    {
        first = second = 0;
        father = NULL;
    }
};
mypair * pt;
mypair pool[500];
size_t ptop;
queue<mypair *> qu;
int a, b, c;
inline mypair * newmypair()
{
    return &pool[ptop++];
}
inline void update(int x, int y, char * s)
{
    if (gp[x][y] == 0)
    {
        mypair * mp = newmypair();
        mp->first = x;
        mp->second = y;
        mp->command = s;
        mp->father = pt;
        qu.push(mp);
        gp[x][y] = gp[pt->first][pt->second] + 1;
    }
}
void print(mypair * p)
{
    stack<string> st;
    while (p != NULL)
    {
        st.push(p->command);
        p = p->father;
    }
    while (!st.empty())
    {
        cout << st.top() << endl;
        st.pop();
    }
}
int main()
{
    scanf("%d%d%d", &a, &b, &c);
    pt = newmypair();
    pt->first = 0;
    pt->second = 0;
    pt->father = NULL;
    qu.push(pt);
    int t = 1;
    gp[0][0] = 1;
    while (!qu.empty())
    {
        pt = qu.front();
        if (pt->first == c || pt->second == c)
        {
            cout << gp[pt->first][pt->second] - 1;
            print(pt);
            goto FINALLY;
        }
        update(a, pt->second, "FILL(1)");
        update(pt->first, b, "FILL(2)");
        update(0, pt->second, "DROP(1)");
        update(pt->first, 0, "DROP(2)");
        if (pt->first + pt->second > b)
            update(pt->first - (b - pt->second), b, "POUR(1,2)");
        else
            update(0, pt->first + pt->second, "POUR(1,2)");
        if (pt->first + pt->second > a)
            update(a, pt->second - (a - pt->first), "POUR(2,1)");
        else
            update(pt->first + pt->second, 0, "POUR(2,1)");
        qu.pop();
    }
    cout << "impossible" << endl;
FINALLY:
    return 0;
}