2016.5.22

1. 高精度整数幂 

心得：乘方特有的计算方式，比较简便清晰

num[0] = 1;
        for (int i = 0; i < n; ++i)
        {
            int b = 0;
            int a = 0;
            for (int j = 0; j < 200; ++j)
            {
                a = num[j] * sum + b;
                num[j] = a % 10;
                b = a / 10;
            }
        }

2.communication system

题目链接：http://cxsjsx.openjudge.cn/2015finalpractice/03/

基础动规，重点理解题意，并写出状态转移方程

dp[i][k] = min(dp[i][k], dp[i - 1][k] + p);

无穷大表示方法:0x3f3f3f3f

贴下代码：

#include <cstdio>  
#include <cstring>  
#include <algorithm>  
using namespace std;
const int inf = 0x3f3f3f3f;//一种巧妙的设置无穷大的方法
int dp[120][1200];

//dp[i][j]表示选了i个设备，i个设备中最小带宽为j时的最低价格
//状态转移方程：dp[i][j] = min(dp[i][j], dp[i - 1][j] + p);
//p为当前枚举到的设备的价格
int main()
{
    int t;
    int n;
    int mi;
    int b, p;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i)//无穷大
        {
            for (int j = 0; j < 1100; ++j)
                dp[i][j] = inf;
        }
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d", &mi);
            while (mi--)
            {
                scanf("%d %d", &b, &p);
                if (i == 1)//赋初值，最底层
                    dp[1][b] = p;
                else
                {
                    for (int k = 0; k < 1100; ++k)//暴力枚举i-1个设备中所有带宽的情况，反正不超时，233
                    {
                        if (dp[i - 1][k] != inf)
                        {
                            //核心，状态转移方程，试着把当前设备放进去
                            if (k >= b)
                                dp[i][b] = min(dp[i][b], dp[i - 1][k] + p);
                            else
                                dp[i][k] = min(dp[i][k], dp[i - 1][k] + p);
                        }
                    }
                }
            }
        }
        double ans = 0;
        for (int k = 0; k < 1100; ++k)
        {
            if (dp[n][k] != inf)
            {
                double temp = (double)k / dp[n][k];
                if (ans < temp)
                {
                    ans = temp;
                }
            }
        }
        printf("%.3lf\n", ans);
    }
    return 0;
}

3.放苹果

基础递归，想到递归方程即解

fun(m, n) = fun(m, n - 1) + fun(m - n, n);

4.古代密码

比较独特的思路，似乎没有普适性

5.恼人的青蛙

很复杂的一道枚举题，注意细节

似乎sort函数需要重载小于号在类外部

bool operator <(const Plant & a, const Plant & b)
{
    if (a.x == b.x)
        return a.y < b.y;
    return a.x < b.x;
}