1.0 2.0 1.0 1.0
2
0.35
0.76

No
Yes

Problem Source: provided by skywind

#include <iostream>
#include <cmath>
using namespace std;

const int MAXN = 100;
const double PI = acos(-1.0);

double R, F, H, K, ans;
int n, cas;

double func(double x) {
    return R / K / (H + F * cos(x));
}

double romberg(double a, double b, double EPS = 1e-6) {
    double t[MAXN][MAXN] = {0}, tmp;
    int i, j, k, k2, m, m4;
    t[0][0] = (func(a) + func(b)) * (b - a) / 2;
    k = 1; k2 = 1;
    while (1) {
        tmp  = 0;
        for (i = 1; i <= k2; i++) {
            tmp += func(a + (2 * i - 1) * (b - a) / (2 * k2));
        }
        t[0][k] = (t[0][k - 1] + tmp * (b - a) / k2) / 2;
        for (m = 1, m4=4; m <= k; m++, m4 *= 4) {
            t[m][k - m] = (m4 * t[m - 1][k - m + 1] - t[m - 1][k - m]) / (m4 - 1);
        }
        if (fabs(t[k][0] - t[k - 1][0]) < EPS) break;
        k++; k2 *= 2;
    }
    return t[k][0];
}

void solve() {
    double tmp;
    scanf("%lf", &tmp);
    if (fabs(tmp - ans) / ans < 0.03) printf("Yes\n");
    else printf("No\n");
}

int main() {
    freopen("2457.in", "r", stdin);
    while (scanf("%lf%lf%lf%lf%d", &R, &F, &H, &K, &n) != EOF) {
        if (cas) printf("\n");
        else cas++;
        ans = romberg(0, PI/2);
        while (n--) {
            solve();
        }
    }
    return 0;
}

(3)pell方程: x^2+ny^2=+-1的解法:
      若n是平方数,则无解, 否则:
      先求出sqrt(n)的连分数序列<x0,x1..xn> 其中xn = 2*x0;
      对于 x^2+ny^2=-1
      若n为奇数,则 x=Pn-1, y=Qn-1; n为偶数时无解
      对于 x^2+ny^2=1
      若n为偶数,则 x=Pn-1, y=Qn-1; n为奇数时x=P2n-1, y=Q2n-1
      注:以上说的解均为最小正解
      
      
      
      

中国剩余定理关键是mf的求法,如果理解了扩展欧几里得 ax+by=d, 就可以想到:
                     mi*mf  mod ni = 1 => mi*mf+ni*y=1;

代码如下:

#include <iostream>
#include <cmath>
using namespace std;

const int MAXN = 100;
int nn, a[MAXN], n[MAXN];

int egcd(int a, int b, int &x, int &y) {
    int d;
    if (b == 0) {
        x = 1; y = 0;
        return a;
    } else {
        d = egcd(b, a%b, y, x);
        y -= a/b*x;
        return d;
    }
}

int lmes() {
    int i, tm=1, mf, y, ret=0, m;
    for (i=0; i<nn; i++) tm *= n[i];
    for (i=0; i<nn; i++) {
        m = tm/n[i];
        egcd(m, n[i], mf, y);
        ret += (a[i]*m*(mf%n[i]))%tm;
    }
    return (ret+tm)%tm;
}

int main() {
    a[0] = 4; a[1] = 5;
    n[0] = 5; n[1] = 11;
    nn = 2;
    printf("%d\n", lmes());
    return 0;
}

Problem B:Checking an Alibi
这题其实就是求每个点到1号点的最短路。 然后判断每只牛所在地到1号点的需时是否小于等于M.
题目没明确说有没有重边，一般情况下是要考虑的。 在比赛时，我们认为数据中有长度为0的边，与题目中1－70000不符。但ACM就是这样，题目出问题是常有的事。在确定自己程序没错的前提下，选手们只能考经验和感觉去猜。

Problem C:The Game of Mafia
直接搜索就行了，白天和黑夜轮着搜，注意一下只剩下他自己的时候的情况就可以了。

Problem D:Multiplication Puzzle
这题是经典的动态规划。
用a[1000]表示愿数组，d[i][j]表示让第i个数与第j个数碰面（删掉他们之间的元素）的最小代价。
方程是：
 d[i][j]= max(d[i][k]+d[k][j]+a[k]*a[i]*a[j]，i<k<j)
时间复杂度是O(n^3)。

Problem E:Zip
这题有两种操作A和B
对于操作A来说只要统计一下各种字母出现的次数就可以很容易得到S'了
而对于操作B来说统计一下序列S'的各种字母的出现次数，然后根据p就可以得到序列的第一个字母和第二个字母，然后根据根据第一个字母就可以得到最后一个字母
比如对于样例来说：
xelpame   7
a      x
e      e
e      l
l      p
m     a
p      m
x      e
确实了第二个字母是x,第一个字母是e，e出现第一次的时候就可以得到最后一个字母是e，
所以根据最后一个字母倒过来生成前面的序列，从对应e的最后一次出现，可以得到倒数第二个字母是l，然后对于l最后出现一次，可以确实l前面是p，然后一直填上去就可以得到原序列S=example

Promble F: Wall
F题考察的是选手基本的计算几何知识。
读懂题意后就是求凸包的周长+一个圆的周长, 求凸包可以先选取最左下角的点，然后以该点为基准对所有点作极角排序，然后就是用Graham扫描法求凸包了。

Problem G:Ouroboros Snake
这题可以用构造算法。 题目有一个限制，2^N 个数不重不漏的出现，这就是关键所在。可以想到，必然有N个零连着，这就是要求数列的开始（以后不可能有N个零连着了）。然后我们每次取后面N-1位，加0看看前是否有这N位。有，那么这一位不能是0（要不就违反了不重不漏了），只能是1。否则就加0。
但是仅仅这样并不能得出正确的答案。 怎么办呢？
想到这个构造算法的结尾必然是很多个1连着（因为加0的话，这N位在前面出现过了）。理想的情况是N个1。那么象 1000，1100，1110这些前面全是1，后面全是0的数就在首尾相接（这是一个圆环）的时候出现了。
修正办法立刻有了，就是在一开始时把象 1000，1100，1110这些前面全是1，后面全是0的数标志为已经出现过。然后用我们之前说的那种构造法一位位的确定那一位是0还是1。
经过检验，发现这样就符合要求了。

PKU 2288 Islands and Bridges
        集合DP
        状态表示: d[i][j][k] (i为13为二进制表示点的状态, j为当前节点, k为到达j的前驱节点)

struct  COSTDATA
{
     int  q;
     int  visit;
} ;

int  dijkstra( int  n)
{
     int  i, j, u, min;
    COSTDATA dist[MAXN];
     int   set [MAXN];
     int  setNum;
     set [ 1 ]  =   1 ; dist[ 1 ].visit  =   - 1 ; dist[ 1 ].q  =   0 ;
    setNum  =   1 ;
     for  (i = 2 ; i <= n; i ++ )
     {
        dist[i].q  =  g[ 1 ][i];
        dist[i].visit  =   0 ;
    }
     while  (setNum  <  n)
     {
        min  =  MAXNUM;
         for  (i = 1 ; i <= n; i ++ )
         {
            
             if  (min  >  dist[i].q  &&  dist[i].visit  !=   - 1 )
             {
                u  =  i;
                min  =  dist[i].q;
            }
        }     
        dist[u].visit  =   - 1 ;
         set [ ++ setNum]  =  u;
         for  (i = 1 ; i <= n; i ++ )
         {
             if  (dist[i].visit  !=   - 1   &&  dist[i].q  >  dist[u].q + g[u][i])
             {
                dist[i].q  =  dist[u].q + g[u][i];
            }
        }     
    }
     return  dist[n].q;
}

 我再根据wy的代码，再优化了一下， 以下是任意两点的最短路径程序：

/**/ /*
 *    beg : 起点;
 *  end : 终点;
 *  n : 顶点个数;
 *  g : 邻接矩阵, 为全局变量, 下标(1, 1)起;
  */

int  dijkstra( int  beg,  int  end,  int  n)
{
     int  i, j, u, min;
     int   * dist  =   new   int [n + 1 ];
     int   * visit  =   new   int [n + 1 ];

     for  (i = 1 ; i <= n; i ++ )
     {
        dist[i]  =  MAXNUM;
        visit[i]  =   false ;
    }

    dist[beg]  =   0 ;
     for  (i = 0 ; i < n; i ++ )
     {
        min  =  MAXNUM;
         for  (j = 1 ; j <= n; j ++ )
         {    
             if  (min  >  dist[j]  &&   ! visit[j])
             {
                u  =  j;
                min  =  dist[j];
            }
        }
         if  (min  ==  MAXNUM)  break ;
        visit[u]  =   true ;
         for  (j = 1 ; j <= n; j ++ )
         {
             if  ( ! visit[j]  &&  dist[j]  >  dist[u] + g[u][j])
             {
                dist[j]  =  dist[u] + g[u][j];
            }
        }
         if  (u  ==  end)  break ;        
    }

     return  dist[end];
}

Description
A narrow street is lined with tall buildings. An x foot long ladder is rested at the base of the building on the right side of the street and leans on the building on the left side. A y foot long ladder is rested at the base of the building on the left side of the street and leans on the building on the right side. The point where the two ladders cross is exactly c feet from the ground. How wide is the street?

Input
Each line of input contains three positive floating point numbers giving the values of x, y, and c.

Output
For each line of input, output one line with a floating point number giving the width of the street in feet, with three decimal digits in the fraction.

Sample Input

30 40 10
12.619429 8.163332 3
10 10 3
10 10 1

Sample Output

26.033
7.000
8.000
9.798

Source
The UofA Local 2000.10.14

My Code:

#include  < iostream >
#include  < algorithm >
#include  < cmath >
#include  < iomanip >
using   namespace  std;

void  round( double  x,  double  y,  double  h) 
{
     double  s1, s2, s;
     double  t, beg, end;
     if  (x  ==  y)  {
        s  =  sqrt(x * x - 4 * h * h);
    }   else   {
         if  (y  <  x)  {
            swap(x, y);
        }
        beg  =   0 ;
        end  =  x;
        s  =  (beg  +  end)  /   2 ;
        t  =   1   /  sqrt(x * x - s * s)  +   1   /  sqrt(y * y - s * s);
         while  (fabs(t - 1 / h) > 0.000000001 )  {
             if  (t  <   1 / h)  {
                beg  =  s;
                s  =  (beg  +  end)  /   2 ;
            }   else   if  (t  >   1 / h)  {
                end  =  s;
                s  =  (beg  +  end)  /   2 ;
            }   else   {
                 break ;
            }
            t  =   1   /  sqrt(x * x - s * s)  +   1   /  sqrt(y * y - s * s);
        }
    }
    cout  <<  setiosflags(ios:: fixed )  <<  setprecision( 3 )  <<  s  <<  endl;
}

int  main() 
{ 
     double  x, y, h;
     while  (cin  >>  x  >>  y  >>  h)  {
        round(x, y, h);
    }
     return   0 ;
}

10点 比赛开始， 看了一下题， 看到在北大的上面做过的"TO THE MAX" ， 万分惊喜， 快速找出 《算法设计与分析》， 同时分配任务给我的队友, chgsh看A题， xp 看B题。心情很紧张，快速的敲这最大子矩阵和的函数， 当时想，这次第一次做出题目的肯定是我们了。。。敲好，提交， NO-wrong answer。心一下子塌下来， 这时候别对队很多都做出的A题(深红色气球)，和G题(粉红色气球)， 这时， chgsh的A题手写出来的， 我就过一旁看C题， 因为我觉得TO THE MAX应该是敲函数的时候出现了一点差错， 要找比较难， 还是先把简单题快点做出来， TO THE MAX晚点再改也行，反正我知道那题不会有太多人能做出来的。。

10点30 chgsh的代码敲完， 调试没问题， 交， NO-wrong answer， 晕， 再改程序， 再交， NO-wrong answer！那时候我们的心情都凝结了， 没想到第一题都做不出， 看到很多红色气球都升起来的， 而我们队还一个气球都没有， 再检查代码， 原来漏掉了结束的标志， 改好， 交! "YES!", 我们不禁叫了出来， 我们互相握手，以示鼓励，毕竟这是0的突破， 意义很大啊！

10点50 xp把写好的B题敲到电脑里面， 交， NO-wrong answer， xp检查代码， 这时我们心情也镇定了， 没有被这NO影响， 我续看C题， 想出来了， xp还在改， 我就继续看G题(这题当时已经有很多人做出来了,所以我想也不难), 想不到就是汉诺塔, 顿时信心十足。这时，晓萍再交程序 NO， 晕死。这时xp叫我一起检查程序，同时把算法告诉我， 我看了程序， 感觉程序一点都没错， 郁闷死。随手把pc^2点出来, 最郁闷的事情发生了， xp交题的时候选错题， 再交, YES! 第二道搞定!

11点20 我决定先把E题(TO THE MAX)检查一遍, 果然, 变量n敲成k了, 改好提交, YES! 我差点跳了起来, 我自己终于做出一题了, 而且那题那个时候还没几个队做出来。chgsh和xp都很高兴， 我们再次握手以示鼓励！

11点50 我继续敲G题(汉诺塔)， 抄了书上的递归程序， 测试， 超时， chgsh说把答案打表吧， 当时我灵机一动， 答案会不会有规律的呢， 决定做个循环把答案打印出来， Bingo, 果然, a[i+1] = 2*a[i] + 1。迅速把程序敲上，提交， YES!

12点 我继续敲C题, 感觉这题比较简单,这时chgsh已经把D题(两页纸的E文)看懂了, 他就和xp商量D题, 而我就继续敲, 当时气氛又紧张了起来,  我想， 如果我把这题拿下了， 那我们对就完成了5题， 拿个小奖应该没问题了。 可能就是这样过于心急， 第一次提交没过， 检查时漏掉了一种情况， 改好交， YES! 看着我们面前那五个颜色的气球。这时已经是12点15分了， 看着面前的面包， 虽然肚子饿， 但是在这种气氛下， 怎么吃得下啊？

12点20分  结合chgsh和我对F题的理解， 觉得F题也不难， 不过F题要考虑的情况很多， 当时头脑发晕， 心情也急， 老是想快点把第6题也做出来(因为这时旁边的队也做了5题)， 于是没有对情况仔细分析， 就去敲代码。。。

13点  代码敲好了， SAMPLE通过， 交吧， NO-wrong answer, 早有预感， 这时xp在手写D题，我想了下我的程序， n个if, n个case, 好混乱， 乱改了一下， 交，在NO-wrong answer， 没法了， 我坐在那里，头好晕。。这时， xp说他的代码写好了，让他试试，OK， 正好我也去冷静下， 仔细想想， F题的情况。

14点 xp敲代码， 而我还在那里发呆， 偶尔看看xp的代码， n个for语句(那题我题意都没理解), 也看不懂他的算法, 头脑就还在发热, 郁闷! 这是chgsh跑过来和我说F题的解法, 给了他想的几个测试数据我, 那几个测试数据就像是救命的灵药, 我开始重新整理思路, 想好F题要改的地方, 这时xp的程序SAMPLE都还没通过, 于是就让我先改F题, 大家都觉得, 做出F题的机会比较大。于是我把我的程序又改了一遍， 再交还是NO-wrong answer。。。。。这时已经离比赛结束只剩下20分钟了。

14点40分  我们的心情都异常的紧张， 因为这时候已经有不少的队伍已经做出了5题(我们旁边那队早就做出了6题了)， 而且我们罚时比较多， 所以情况对我们很不利， 我们必须做出第6题才能有较大的机会拿奖。可是， 对F题， 我已经没有办法了， xp的D题他也没把握， 这时候， chgsh又想到了几个使我的程序错的测试数据， 于是赶紧改上， 没问题， 交。这时候只剩下不到15分钟了， 返回结果：YES!  居然YES了, 是YES!那种感觉, 只能用狂喜来形容!我们再次握手, 我们有机会了!

14点45分 我们还没有放弃, xp上去改他的D题, 居然前两组SAMPLE过了, 叫他赶紧交, 交了再改, 只剩下10分钟了, NO-wrong answer! 这是我们三个一起注视这显示器, 到底那里错呢? 按我的经验, 肯定是溢出问题, 于是叫xp把程序里的1e10改成1000000000交上去试试。 本就没想过能过的， 谁知道， 跳出一个YES的对话框， "过了?" , "我们队做了7题了！"， "xp你太厉害了"， 我们兴奋得差点从椅子上跳起来。我想现在最不爽的肯定是我们旁边的那队， 一直领先我们， 居然在最后20分钟出现了奇迹。。。

15点 比赛结束 周杰老师公布:"有2支队做完了8题， 两支队做了7题。。。"

后记：这次比赛， 给我的唯一感觉就是神奇， 真的是太神奇了， 特别是最后20分钟做出两题， 是三个人合作的成果， 这就是ACM的乐趣， 在这， 我要感谢我的队友chgsh和xp, 我要说："AUCS， 好样的!"


我们队(team64)的排名:

Description

7

3   8

8   1   0

2   7   4   4

4   5   2   6   5



(Figure 1)

Input
Your program is to read from standard input. The first line contains one integer N: the number of rows in the triangle. The following N lines describe the data of the triangle. The number of rows in the triangle is > 1 but <= 100. The numbers in the triangle, all integers, are between 0 and 99.

Output
Your program is to write to standard output. The highest sum is written as an integer.

Sample Input

5
7
3 8
8 1 0 
2 7 4 4
4 5 2 6 5

Sample Output

30

Source
IOI 1994

#include<iostream>
using namespace std;

int main()
{
    int n,digital_num;
    int result[100][100];
    int *num;
    int max = 0;
    int i,j;
    cin>>n;
    digital_num = n;
    num = new int[digital_num];

    for (i = 0; i<n; i++)
    {
        for (j = 0; j<=i; j++)
        {
            cin>>num[j];
            if (i==0)
                result[i][j] = num[j];
            if (i>0)
            {
                if (j==0)
                    result[i][j] = result[i-1][j]+num[j];
                if (j==i)
                    result[i][j] = result[i-1][j-1]+num[j];
                if (j>0&&j<i)
                {
                   if (result[i-1][j]>result[i-1][j-1])
                       result[i][j] = result[i-1][j]+num[j];
                   else
                       result[i][j] = result[i-1][j-1]+num[j];
                }
            }
        }
    }
    
    for (i = 0; i<n; i++)
        if (result[n-1][i]>max)
            max = result[n-1][i];

    cout<<max<<endl;
    return 0;
}