左上是 gdb, 右上是 gvim, 下面是编译 + 输出

不会 vim 的诸多中高级应用, 就这样玩还是很舒服的~ 哈哈.

注意到了么, 下面那个终端里的命令是:

mygcc msquare

实际是, mygcc 是我在 .bashrc 里面定义的终端”快捷键”哈!! 原形是:

python mygcc.py

至于这个 mygcc.py 嘛, 就是个接受一个参数(就是程序名 program), 然后在终端执行这串命令(我不会 bash 脚本的编写.. 就用 python 来写了个.. 嘿嘿~):

1
2
3

gcc -Wall -g -o program program.c
./program
cat program.out

这样就可以编译 + 运行 + 输出一连串的搞定了哈^^ 很多 IDE 还没这样呢.. 特别是最后的 cat 输出文件.. 哈哈.

You may like these posts:

• 这些天的事儿 (21)
• 不为 OI 的 OI (35)
• 暑假OI计划 (18)
• USACO刷题记录 (73)
• GDOI2008,GAME OVER (20)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/how-i-use-vim-to-program.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

我不得不承认, 我实在幼稚. 我下的赌注太大了, 将家人的所有阻挠押到两个字上 — 保送. 对于我, NOIP, –> GDOI –> NOI, 每一个, 都是唯一. 赛前, 我很不安. 我怕, 还没起飞就摔下来. 可现实就是这么残酷.

当为 “放弃” 二字落泪时, 我知道, 梦, 抑或说, 是幻想, 碎了.
当上课听着听着突然想起一个算法时, 我知道, 那是依恋.
当晚自习埋头写着写着写出一段代码时, 我知道, 那是眷顾.
当在 operamini 中打开 vijos 时, 我知道, 那是不舍.
终于, 我一次, 又一次的往电脑室跑…. 可是, 还为了什么?

赌局, 已经让我倾家荡产了. 爸妈爆发的失望, 将 OI 压入了深谷. 最高指示, 唯一目标: 高考.

高考, 高考….

我想要做的事情很多, 实在太多了. 不仅一次的幻想, 空闲的时候, 我能做多么多的事情. 可是, 不但没有空闲, 事情反而更多了. 高考, 这个可以占据整个高中三年的字眼, 我逃了一年多, 终归, 还是逃不出. 不, 我要寻找希望, 哪怕只是一丝一丝. 于是, 我问了 Google, 问了在高三奋斗的学长, 问了敬仰的大牛. 我错了, 即使是高三还有一次 NOIP, 可还是有高考的束缚. 真的, 连一丝光线都没有. 那个俘获了我整颗心的白日梦, 该醒了吧. 可是, 我的依恋, 我的眷顾, 我的不舍….

当我不再登录一些网络上的应用, 当我放下凤凰木的管理, 当我应付社团课; 当我把 codes 装进 U 盘里带着满世界跑, 当我在学校缩在被窝里用手机看题, 当我周末回家深夜爬起来装 Ubuntu, 当我开始用 C 刷 USACO 和 vijos, 不为 OI 的 OI….

在 GDOI2008 时, 中大的 ACMer 说: 中学圆不了的梦, 到大学来圆.
把梦, 带进大学?

[Audio clip: view full post to listen]

同样放不下的, 是这个记载着我幼稚的文字的 blog…. 升级到 2.6.5, 换个主题, 继续写吧.

You may like these posts:

• 菜鸟是怎样用 vim 来编程的 (11)
• 这些天的事儿 (21)
• FALSE (6)
• 暂停更新 for NOIP2008 (16)
• NOIP2008’s Desktop (9)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/oi-not-for-oi.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

program leewings;
 
begin
    assign(input,'memory.in'); assign(output,'memory.out');
    reset(input); rewrite(output);
    NOIP2008:=240;
    repeat
       销声匿迹;
    until unknow;
    close(input); close(output);
end.

You may like these posts:

• 不为 OI 的 OI (35)
• 暂停更新 for NOIP2008 (16)
• NOIP2008’s Desktop (9)
• NOIP2005普及组 解题报告 (4)
• NOIP2006普及组 解题报告 (2)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/false.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

为了走这条路, 我放了很多空话, 做了很多傻事, 失去了很多东西, 对不起很多人….
压力, 瞬间爆发.
NOIP2008, 势在必得!

You may like these posts:

• 不为 OI 的 OI (35)
• FALSE (6)
• NOIP2008’s Desktop (9)
• NOIP2005普及组 解题报告 (4)
• NOIP2006普及组 解题报告 (2)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/pause-update-for-noip2008.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

这篇就写最最基本的 DP.. 背包问题`~[咳咳, 扔砖头的请便..]

W : 背包限重;
V[i,j] : 前 i 个物品中选到重量为 j 时的最佳价值;
F[i,j] : 前 i 个物品中选到重量恰为 j 的情况 (boolean 型);
W[i] : 第 i 个物品的重量;
P[i] : 第 i 个物品的价值;
k : 物品数量;

0-1 背包问题
• 剩余最小载重

  状态方程 : F[i,j]=F[i-1,j-W[i]] (W[i]<=j<=W)
  边界条件 : F[0,0]=true
   
  实现:
  for i:=1 to n do
    for j:=w[i] to W do F[i,j]:=F[i-1,j-W[i]];

• 求最大价值

  状态方程 :
  -- V[i,j]=0 (i=0 or j=0)
  -- V[i,j]=V[i-1,j] (j<w[i])
  -- V[i,j]=max{V[i-1,j], V[i-1,j-W[i]]+P[i]} (i>0 and j>=W[i])

可重复背包
• 剩余最小载重

  状态方程 : F[i,j]=F[i-1,j-W[i]*k] (W[i]<=j<=W and k=1..j div W[i])
  边界条件 : F[0,0]=true

• 求最大价值

  状态方程 :
  -- V[i,j]=0 (i=0 or j=0)
  -- V[i,j]=V[i-1,j] (j<w[i])
  -- V[i,j]=max{V[i-1,j], V[i-1,j-W[i]*k]+P[i]*k} (i>0 and j>=W[i] and k=1..j div W[i])

You may like these posts:

• 超基本算法(四) — 搜索 (3)
• 超基本算法(三) — 树的遍历 (7)
• 超基本算法(二) — 排序 (6)
• 超基本算法(一) — 数论 (9)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/basic-algorithm-5-bag.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

这篇充数的 post, 只是写 DFS 和 BFS 的框架.. 至于剪枝 / 双向 BFS 等呢…. 就算了吧.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

program DFS;  //深度优先搜索 递归算法
 
procedure DFSTRY(i)；  //递归过程
begin
    for i=1 to maxr do begin
      if 子结点mr符合条件 then begin
         产生的子结点mr压人栈；
         if 子结点mr是目标结点 then 输出 else DFSTRY(i+1)；
        栈顶元素出栈(删去Mr)
      end;
    end;
end;
 
begin
  初始状态入栈；
  DFSTRY(1)；
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

program DFS(dcp)； //深度优先搜索 非递归算法, 其实我基本不用这个的.... 向来都直接递归..
 
procedure backtracking;  //回溯过程
begin
  dep:=dep-1;
  If dep>0 then 取回栈顶元素
  eIse p: =true;
end;
 
begin
  dep:=0;
  repeat
    dep:=dep+1;
    j:=0; p:=false;
    repeat
      j:=j+1;
      if mr 符合条件 then begin
        产生子结点 mr 并将其记录;
        if 子结点是目标结点 then 印输出并出栈  else p:=true;
      end
      else
         if j>=maxi then backtracking else p: =false;
      end;
    until p=true;
  until dep=0;
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

program  BFS;  //广度优先搜索
 
begin
  初始化; 把初始布局存入数据库data;
  设首指针closed:=1; 尾指针open:=0
 
  repeat
    inc(open);
    取出open所指结点进行扩展;
    for r:=1 to max do begin  //r为产生规则编号
      if 子结点符合条件 then begin
          inc(closed);
          把新接点存入数据库队尾;
          if 新结点与原结点重复 then 删除新结点(dec(closed))
         else if 新结点即目标 then 输出并退出;
      end
    end
  until open>=closed  //队列空
end.

You may like these posts:

• 超基本算法(五) — 背包 (4)
• 超基本算法(三) — 树的遍历 (7)
• 超基本算法(二) — 排序 (6)
• 超基本算法(一) — 数论 (9)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/basic-algorithm-4-search.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

基本的树的遍历呢, 就是先序/中序/后序遍历的生成啦~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

program get_pre; //已知中序和后序, 求先序遍历.
var pre,mid,post:string;
 
procedure getpre(mid,post:string);
var i:longint;
begin
  if (mid='') or (post='') then exit;
  i:=pos(post[length(post)],mid);
  pre:=pre+post[length(post)]; //根
  getpre(copy(mid,1,i-1),copy(post,1,i-1));  //左
  getpre(copy(mid,i+1,length(mid)-i),copy(post,i,length(post)-i));  //右
end;
 
begin
  pre:='';
  readln(mid);
  readln(post);
  getpre(mid,post);
  writeln(pre);
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

program get_mid;  //已知先序和后序, 求中序的一种
var pre,mid,post:string;
 
function check(pre,post:string):boolean; //判断两序列的元素是否完全相同
var i,j:longint;
    p:boolean;
begin
  for i:=1 to length(pre) do begin
    p:=false;
    for j:=1 to length(post) do if pre[i]=post[j] then p:=true;
    if not p then exit(false);
  end;
  exit(true);
end;
 
procedure getmid(pre,post:string);
var i:longint;
begin
  if (pre='') or (post='') then exit;
  i:=0;
  repeat
    inc(i);
  until check(copy(pre,2,i),copy(post,1,i));
  getmid(copy(pre,2,i),copy(post,1,i)); //左
  mid:=mid+pre[1];  //根
  getmid(copy(pre,i+2,length(pre)-i-1),copy(post,i+1,length(post)-i-1));  //右
end;
 
begin
  readln(pre);
  mid:='';
  readln(post);
  getmid(pre,post);
  writeln(mid);
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

program get_post;  //已知先序和中序, 求后序遍历
var pre,mid,post:string;
 
procedure getpost(pre,mid:string);
var i:longint;
begin
  if (pre='') or (mid='') then exit;
  i:=pos(pre[1],mid);
  getpost(copy(pre,2,i),copy(mid,1,i-1));  //左
  getpost(copy(pre,i+1,length(pre)-i),copy(mid,i+1,length(mid)-i));  //右
  post:=post+pre[1];  //根
end;
 
begin
  readln(pre);
  readln(mid);
  post:='';
  getpost(pre,mid);
  writeln(post);
end.

You may like these posts:

• 超基本算法(五) — 背包 (4)
• 超基本算法(四) — 搜索 (3)
• 超基本算法(二) — 排序 (6)
• 超基本算法(一) — 数论 (9)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/basic-algorithm-3-tree.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

P.S.: wp-syntax 看起来超爽..~!!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

program sort;
var a,b:array[0..100000] of longint;
    n,i:longint;
 
procedure qsort(l,r:longint); //快速排序
var i,j,mid,temp:longint;
begin
  i:=l; j:=r; mid:=a[(l+r) div 2];
  repeat
    while a[i]<mid do inc(i);
    while a[j]>mid do dec(j);
    if i<=j then begin
      temp:=a[i]; a[i]:=a[j]; a[j]:=temp;
      inc(i); dec(j);
    end;
  until i>j;
  if i<r then qsort(i,r);
  if l<j then qsort(l,j);
end;
 
procedure insert_sort; //插入排序
var i,j:longint;
begin
  for i:=2 to n do begin
    a[0]:=a[i];
    j:=i-1;
    while a[0]<a[j] do begin
      a[j+1]:=a[j];
      dec(j);
    end;
    a[j+1]:=a[0];
  end;
end;
 
procedure choose_sort; //选择排序
var i,j,temp:longint;
begin
  for i:=1 to n-1 do
    for j:=i+1 to n do
      if a[i]>a[j] then begin
        temp:=a[i]; a[i]:=a[j]; a[j]:=temp;
      end;
end;
 
procedure bubble_sort; //冒泡排序
var i,j,temp:longint;
begin
  for i:=1 to n-1 do
    for j:=n downto i+1 do
      if a[j]<a[j-1] then begin
        temp:=a[j]; a[j]:=a[j-1]; a[j-1]:=temp;
      end;
end;
 
procedure write_sort; //输出..
var i:longint;
begin
  for i:=1 to n do write(a[i],' ');
  writeln;
end;
 
begin
  readln(n);
 
  randomize;
  for i:=1 to n do b[i]:=random(100);
 
  a:=b;
  qsort(1,n); //快排
  write_sort;
 
  a:=b;
  insert_sort; //插入排序
  write_sort;
 
  a:=b;
  choose_sort; //选择排序
  write_sort;
 
  a:=b;
  bubble_sort; //冒泡排序
  write_sort;
end.

You may like these posts:

• 超基本算法(五) — 背包 (4)
• 超基本算法(四) — 搜索 (3)
• 超基本算法(三) — 树的遍历 (7)
• 超基本算法(一) — 数论 (9)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/basic-algorithm-2-sort.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

1
2
3
4
5
6
7
8
9
10
11
12
13

program gcd; //Greatest Common Divisor 最大公约数
var a,b:longint;
 
function gcd_ab(a,b:longint):longint;
begin
  if b=0 then exit(a)
  else gcd_ab:=gcd_ab(b, a mod b);
end;
 
begin
  readln(a,b);
  writeln(gcd_ab(a,b));
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

program lcm; //Lowest Common Multiple 最小公倍数
var a,b:longint;
 
function lcm_gcd(a,b:longint):longint; //利用 gcd 来求 lcm
  function gcd(a,b:longint):longint;
  begin
    if b=0 then exit(a)
    else gcd:=gcd(b, a mod b);
  end;
 
begin
  lcm_gcd:=a * b div gcd(a,b);
end;
 
function lcm_row(a,b:longint):longint; //直接求 lcm
var temp:longint;
begin
  if a<b then begin
    temp:=a; a:=b; b:=temp;
  end;
  lcm_row:=a;
  while lcm_row mod b > 0 do inc(lcm_row, a);
end;
 
begin
  readln(a,b);
  writeln(lcm_gcd(a,b));
  writeln(lcm_row(a,b));
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

program prime; //判断输入的数 (longint 范围内) 是否质数
var n:longint;
 
function check_prime(n:longint):boolean;
var i:longint;
begin
  for i:=2 to trunc(sqrt(n)) do
    if n mod i = 0 then exit(false);
  exit(true);
end;
 
begin
  readln(n);
  writeln(check_prime(n));
end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

program getprime; //筛法求素数
var n:longint;
    p:array[0..100000000] of boolean;
 
procedure get_prime(n:longint);
var i,j:longint;
begin
  fillchar(p,sizeof(p),1);
  for i:=2 to n do
    if p[i] then begin
      write(i,' ');
      j:=i;
      while j<=n do begin
        p[j]:=false;
        inc(j,i);
      end;
    end;
end;
 
begin
  readln(n);
  get_prime(n);
  writeln;
end.

You may like these posts:

• 超基本算法(五) — 背包 (4)
• 超基本算法(四) — 搜索 (3)
• 超基本算法(三) — 树的遍历 (7)
• 超基本算法(二) — 排序 (6)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/basic-algorithm-1-number-theory.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

You may like these posts:

• 不为 OI 的 OI (35)
• FALSE (6)
• 暂停更新 for NOIP2008 (16)
• NOIP2005普及组 解题报告 (4)
• NOIP2006普及组 解题报告 (2)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/noip2008s-desktop.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

简单的来说,九连环是这样的(具体的话,自己G一下吧^^)—

一根棒子上有九个连环(从左到右依次编号),必须按照某种特殊的规则才能将九个连环全部解出:

• 一次只能把一个环取下或套上;
• 编号为1的环无论何时都能取下或套上;
• 如果编号为1,…,k-1(1<=k<=9)的环已经取下,并且k还在棒上,那么可以取下编号为k+1的环.

小时候玩过…..很繁琐的过程来的…..
实际上,我们可以从九连环拓展到n连环.

先来看看五连环的解法吧:
共21步.

0代表将环解下,1代表套上.

11111–>初始状态,所有环都是套上的.
01111–>第一步,将1解下.
01011–>第二步,将3解下.
11011
10011
00011
00010
10010
11010
01010
01110
11110
10110
00110
00100
10100
11100
01100
01000
11000
10000
00000

简单分析可知,要解开5,必须解开3及以前的,保留4;解开3,必须解开1,保留2..
这么一来,解五连环,关键在于解1->3->5,其中2、4相当于跳马..

将以上的步骤简记为:

1↓ 3↓ 1↑ 2↓ 1↓ 5↓ {[(1↑ 2↑ 1↓) 3↑ (1↑ 2↓ 1↓)] 4↓ [(1↑ 2↑ 1↓) 3↓ (1↑ 2↓ 1↓)]}

由上,不难看出其中出现了重复.
1↑ 2↑ 1↓,1↑ 2↓ 1↓—这些是对环2的操作“且可知,套上实际上是解下的逆过程~
1↑ 2↑ 1↓ 3↑ 1↑ 2↓ 1↓—对环3的操作
1↑ 2↑ 1↓ 3↑ 1↑ 2↓ 1↓ 4↓ 1↑ 2↑ 1↓ 3↓ 1↑ 2↓ 1↓—对环5的操作.

定义F[k]为将环k套上或解下(并使得1~k-1环都不与其同状态)的总操作次数;f[k]为对环k套上或解下的单此操作.
可以看出,环3的操作实际上是:F[2]+f[3]+F[2];
环4的操作实际上是:F[3]+f[4]+F[3].
而f[k]总是1.

由此可得出F[k]的递推方程:

F[i]=F[i-1]+1+F[i-1]...

再来分析关键环1、3、5的解下操作的前后.
1:1↓
3:1↓ 3↓ 1↑ 2↓ 1↓
5:1↓ 3↓ 1↑ 2↓ 1↓ 5↓ 1↑ 2↑ 1↓ 3↑ 1↑ 2↓ 1↓ 4↓ 1↑ 2↑ 1↓ 3↓ 1↑ 2↓ 1↓

定义G[k]为解下关键环总操作次数.
类似于得出上一个递推方程的思路,可得:

G[k]=G[k-2]+1+F[k-1]

拓展五连环,就可以得出,九连环的总步骤数实际上就是解关键环1、3、5、7、9的总操作数罢了.
结果是341步.

思考归纳后可得,以上方法即为解/套奇数连环的方法啦.
那偶数连环呢?

这就简单啦.
既然奇数连环的关键环是编号为奇数的环,那偶数连环的关键环就是编号为偶数的环啦~
那么,第一个解下环2,往后类似就好了,就不再说一次啦.

九连环之成熟期代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

var n:longint;
    steps,answer:array[1..1000] of int64;
 
procedure get_steps;
var i:longint;
begin
  steps[1]:=1;
  for i:=2 to n-1 do steps[i]:=steps[i-1]+1+steps[i-1];
end;
 
procedure get_ans_odd;
var i:longint;
begin
  answer[1]:=1;
  for i:=3 to n do
    if odd(i) then answer[i]:=answer[i-2]+1+steps[i-1];
end;
 
procedure get_ans_not_odd;
var i:longint;
begin
  answer[2]:=2;
  for i:=4 to n do
    if not(odd(i)) then answer[i]:=answer[i-2]+1+steps[i-1];
end;
 
begin
  readln(n);
  get_steps;
  if odd(n) then get_ans_odd else get_ans_not_odd;
  writeln(answer[n]);
end.

来看看1~5的输出:

1. 1
2. 2
3. 5
4. 10
5. 21

找吖找规律….
OMG!规律竟然如此简单….

归纳一下,设T[k]为解开k连环所需总操作数,则

if odd(k) then T[k]=T[k-1]*2+1
else T[k]=T[k-1]*2

over..更为简单的解法出现啦!(数学上可以证明其正确性吧,我没去证..)
由此猜想,32连环的步数恰好爆长整型,64连环的步数恰好爆64位长整型.
编程验证之,正确…so…想过要看100连环的步数..要高精度…算了,懒得写了-_-~!!

既然观察这么强悍,那么再观察一下.
这回观察前面五连环解法的0/1表示,咦,有似曾相识的感觉?
再看看解法的规则:一次只能把一个环取下或套上.

Get it.
其实解法的第m步就是第n-m个格雷码的逆序输出….
反之,套上的方法,第m步就是第m个格雷码的逆序输出….Orz..
P.S.:关于格雷码
再P.S.:哎…..中国伟大的古人们在西汉时期(最早提及九连环的MS是司马相如?)就在玩九连环了…可是,就是没人发现格雷码….好吧,正如传说中”东方不亮罗国亮”的深中历史老师所言:中国古代有技术但没科学!

九连环之完全体(总步数的递推计算+详细步骤的gray_code逆序输出)代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

var n,i,ans:longint;
 
procedure change(m:longint);
var i,p:longint;
    s:array[1..100] of byte;
begin
  p:=0;
  while m<>0 do begin
    inc(p);
    s[p]:=m mod 2;
    m:=m div 2;
  end;
  s[p+1]:=0;
  for i:=1 to p do s[i]:=s[i] xor s[i+1];
  for i:=1 to p do write(s[i]);
  if p<n then for i:=p+1 to n do write('0');
  writeln();
end;
 
begin
  assign(output,'gray-code.out');rewrite(output);
  readln(n);
  ans:=0;
  for i:=1 to n do
    if odd(i) then ans:=ans*2+1 else ans:=ans*2;
  writeln(ans);
 
  for i:=ans downto 1 do change(i);
  for i:=1 to n do write('0');writeln();
  close(output);
end.

睡觉前突然想到….
既然套上的方法,第m步就是第m个格雷码…而最后一步总是n个1(逆序也一样吖…)…
那么,将n个1解码成二进制,再换算成十进制不就是步数?!

编程验证之,GAME OVER.

九连环之究极体代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

var n:longint;
    step:int64;
    gray_code:array[1..1000] of byte;
 
function change(n:longint):int64;
var i:longint;
    temp,two:int64;
begin
  for i:=1 to n do gray_code[i]:=1;
  for i:=n-1 downto 1 do gray_code[i]:=gray_code[i] xor gray_code[i+1];
  two:=1;temp:=0;
  for i:=1 to n do begin
    temp:=temp+gray_code[i]*two;
    two:=two shl 1;
  end;
  exit(temp);
end;
 
begin
  readln(n);
  step:=change(n);
  writeln(step);
end.

一个九连环问题,步步归纳,得出三种解法(存在递进关系的?).
K.O.

You may like these posts:

• 幻想三国志肆 (7)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/9-chain-of-rings.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

GDOI2008后,fengzi牛正式退役了.
今天,fengzi牛又给了我一堆书(或者说,我继承了?N多代代相传的….最古老的是97年的…..)..
我成了深中唯一一个OIer了..(先佩服一下深圳…GDOI从第一到第八都坐过….这一记录,绝无仅有..-_-~!)

周末去买本本给自己了.
本来想去香港买的…结果,港澳通行证必须要回户口所在地办理..我的户口在湛江不在深圳–!没戏了..只能乖乖去华强北了…
今天偷偷去了华强北..看到了几款心仪的~准备就绪,只待周末~~!
有了自己的本本(现在这个是姐姐的..)以后,就该开始奋斗了,说过的,暑假,我是疯子.

先说下手头上有的资料:

• 实体书籍.
  1. <NOI专刊>若干
  2. <算法导论>
  3. <算法艺术与信息学竞赛>
  4. <图论的算法与程序设计>
  5. GDOI和GDKOI时候才发的所谓<资料集>×9
  6. <奥赛经典之奥林匹克数学中的组合问题>(数学的….对OI有用,学之.)
  7. <奥赛经典之信息学奥林匹克教程提高篇>
  8. <国际大学生程序设计竞赛例题解(一)>-<数论、计算几何、搜索算法专集>
  9. <国际大学生程序设计竞赛例题解(二)>-<广东省大学生程序设计竞赛试题(2003-2005年)>
  10. <国际大学生程序设计竞赛例题解(三)>-<图论、动态规划算法、综合题专集>
  11. <国际大学生程序设计竞赛例题解(四)>-<广东省信息学奥林匹克竞赛试题(2003-2006年)>
• 电子书籍.
  1. <贪心导论>
  2. <基本算法>
  3. <骗分导论>(….)
  4. (黑书)
  5. <计算机程序设计艺术>

好多….可是我只有一年时间..啊.
不疯不行了…

以下就是疯子的计划.

• 看书
  1. <NOI专刊>若干,短期内消灭!有一些还是看不懂的…等能力提升了再好好的看!
  2. <算法艺术与信息学竞赛>要啃完啃好!
  3. 辅之以<图论的算法与程序设计>
  4. <奥赛经典之信息学奥林匹克教程提高篇>透掉.
  5. <贪心导论>KO掉.
  6. <基本算法>同样KO之.
  7. <骗分导论>……赛前再看吧..
• 做题
  1. USACO刷完.
  2. <国际大学生程序设计竞赛例题解(一)>-<数论、计算几何、搜索算法专集>要全AC.
  3. <国际大学生程序设计竞赛例题解(三)>-<图论、动态规划算法、综合题专集>还是要全AC.

That’s not all,
but waiting for I to finish them!

继承fengzi牛的又一疯子,
Leewings牛即将出现.

You may like these posts:

• 菜鸟是怎样用 vim 来编程的 (11)
• 这些天的事儿 (21)
• 不为 OI 的 OI (35)
• USACO刷题记录 (73)
• GDOI2008,GAME OVER (20)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/oi-plan-for-summer-holiday.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

最后一个是代表我正在做的..~

手动刷新太麻烦了….一次过贴入一个Section的吧…..最后一个Section表示我正在刷~

会在评论中加入我自己的解题思路~(这篇文章写得晚….解题会从1.4.1开始…)

呵呵,或许很幼稚的吧^^

Just for Fly&Fun^^

P.S.:所有翻译来自:NOCOW

Chapter1

Section 1.1

• Your Ride Is Here (ride) (翻译)
• Greedy Gift Givers (gift1) (翻译)
• Friday the Thirteenth (friday) (翻译)
• Broken Necklace (beads) (翻译)

Section 1.2

• Milking Cows (milk2)(翻译)
• Transformations (transform)(翻译)
• Name That Number (namenum)(翻译)
• Palindromic Squares (palsquare)(翻译)
• Dual Palindromes (dualpal)(翻译)

Section 1.3

• Mixing Milk (milk)(翻译)
• Barn Repair (barn1)(翻译)
• Calf Flac (calfflac)(翻译)
• Prime Cryptarithm (crypt1)(翻译)

Section 1.4

• Packing Rectangles (packrec)(翻译)
• The Clocks (clocks)(翻译)
• Arithmetic Progressions (ariprog)(翻译)
• Mother’s Milk (milk3)(翻译)

Section 1.5

• Number Triangles (numtri)(翻译)
• Prime Palindromes (pprime)(翻译)
• SuperPrime Rib (sprime)(翻译)
• Checker Challenge (checker)(翻译)

Chapter2

Section 2.1

• The Castle (castle) (翻译)
• Ordered Fractions (frac1) (翻译)
• Sorting A Three-Valued Sequence (sort3) (翻译)
• Healthy Holsteins (holstein) (翻译)
• Hamming Codes (hamming) (翻译)

Section 2.2

• Preface Numbering (preface) (翻译)
• Subset Sums (subset) (翻译)
• Runaround Numbers (runround) (翻译)
• Party Lamps (lamps) (翻译)

Section 2.3

• The Longest Prefix (prefix) (翻译)
• Cow Pedigrees (nocows) (翻译)
• Zero Sum (zerosum) (翻译)
• Money Systems (money) (翻译)
• Controlling Companies (concom) (翻译)

Section 2.4

• The Tamworth Two (ttwo) (翻译)
• Overfencing (maze1) (翻译)
• Cow Tours (cowtour) (翻译)
• Bessie Come Home (comehome) (翻译)
• Fractions to Decimals (fracdec) (翻译)

Chapter3

Section 3.1

• Agri-Net (agrinet)(翻译)
• Score Inflation (inflate) (翻译)
• Humble Numbers (humble) (翻译)
• Shaping Regions (rect1) (翻译)
• Contact (contact) (翻译)
• Stamps (stamps) (翻译)

Section 3.2

• Factorials (fact4) (翻译)
• Stringsobits (kimbits) (翻译)
• Spinning Wheels (spin) (翻译)
• Feed Ratios (ratios) (翻译)
• Magic Squares (msquare) (翻译)
• Sweet Butter (butter) (翻译)

Section 3.3

• Riding The Fences (fence) (翻译)
• Shopping Offers (shopping) (翻译)
• Camelot (camelot) (翻译)
• Home on the Range (range) (翻译)
• A Game (game1) (翻译)

Section 3.4

• Closed Fences (fence4) (翻译)
• American Heritage (heritage) (翻译)
• Electric Fence (fence9) (翻译)
• Raucous Rockers (rockers) (翻译)

Chapter4

Section 4.1

• Beef McNuggets (nuggets) (翻译)
• Fence Rails (fence8) (翻译)
• Fence Loops (fence6) (翻译)
• Cryptcowgraphy (cryptcow) (翻译)

Section 4.2

• Drainage Ditches (ditch) (翻译)
• The Perfect Stall (stall4) (翻译)
• Job Processing (job) (题解)
• Cowcycles (cowcycle) (翻译)

Section 4.3

• Buy Low, Buy Lower (buylow) (翻译)
• The Primes (prime3) (翻译)
• Street Race (race3) (翻译
• Letter Game (lgame) (翻译)

Section 4.4

• Shuttle Puzzle (shuttle)(翻译)
• Pollutant Control (milk6) (翻译)
• Frame Up (frameup) (翻译)

You may like these posts:

• 菜鸟是怎样用 vim 来编程的 (11)
• 这些天的事儿 (21)
• 不为 OI 的 OI (35)
• 暑假OI计划 (18)
• GDOI2008,GAME OVER (20)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/usaco-record.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

• No.1
  1. 送分题,AC(30分)
  2. 双广,0分.我的做法是单广,4000W的状态,判重很猥琐….挂定.
  3. 图论的题目….我随便弄了个蒙点的程序…15分
  4. “4个关键字排序比较的问题…弄颗树来扫啊.”评讲时人家说的…我0分

• No.2
  1. 送分题,找规律的.糊里糊涂没弄出来,0分…
  2. DP…难题,没弄出来,0分.
  3. 贪心.策略完全正确,弄了个n^2的算法….20分,50%的点.实际上,n的算法想到了,但没去编….
  4. 能力+技巧要求很高的一道题…二分的,不知道该怎么去说这道题(我的水平很低…..).n^5的程序,蒙到了8分.(全场没有满分的..)..

两试总分:73.
GDOI2008三等线:74,好了,郁闷了下…

总的来说,这次其实应该能AC掉第二试的1、3题的..100分就上去了吖…二等线才107….
多有价值的二等啊…废了.反而深圳两个初中的都比我高分..郁闷了.

这次比赛,最难受的还是fengzi牛.
深圳最有希望进省队的牛,第一试郁闷了…第二试电脑出问题了….
才三等奖了…
fengzi牛不甘到中大,要拼高考了….

好吧,第一次GDOI,就这样废了….好了,不理了.

距NOIP2008还有百来天..
拼了,打死都要弄到个一等奖,这样才好说话了吖.!!
要是这个一等奖没有..哎,估计我的OI路从此终结.

这个暑假,一个疯子即将出现..

You may like these posts:

• 7.4-7.8,GDOI2008 (3)
• 菜鸟是怎样用 vim 来编程的 (11)
• 这些天的事儿 (21)
• 不为 OI 的 OI (35)
• 暑假OI计划 (18)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/gdoi2008-game-over.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

P.S.:昨天要交政治作业….没交.今天刘总(政治老师)问限令我明天下午前交….
课后,跟他说明天要去比赛一个星期,
刘总say:噢噢,好好比赛吧,这个没事,特殊情况,没事的.

KO.
刘总真棒~!!
爽~^^

GDOI2008,
目标:前30.冲击!!

You may like these posts:

• GDOI2008,GAME OVER (20)
• 菜鸟是怎样用 vim 来编程的 (11)
• 这些天的事儿 (21)
• 不为 OI 的 OI (35)
• 暑假OI计划 (18)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/74-78-gdoi2008.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

GDOI商场(这题是弄GDOI的人出的….)…….(忽略故事性描述.~)

有一堆商品,每种都能省到一定的钱,但每种只能买一件,而且有些是不能同时买的.不能同时买的商品中,不会出现一个环(即类似于”C1与C2不能同时买,C2与C3不能同时买,C3与C1不能同时买”这样的情况是不会出现的).

编程求能节省的最大金额数.

这回稍微说明下输入:

输入中,第一行K(商品种数),M(不能同时买的对数).
接下来K行,第i行有一个整数表示购买编号i的商品可以节省的金额;再接下来M行,每行两个数,表示这两件商品不能同时购买.

图啊图啊图….对于图知识约等于0的我来说..分析这题花了很多时间…..

据说,这题的关键是构造一个结点带权的图,结点表示商品,结点的权就是购买该商品能节省的$$,边表示边所连的两个点的商品不能同时购买.这就相当于在这幅图中找出一系列的没有边相连的点,且权值之和最大~~
由于题目的最后一个条件,这张图里面是没有环滴..也就是,是树林吖….我们的目的就是算出每棵树的最大节省金额,然后求和.

这题DP起来,状态方程倒不难得出,一颗颗树来做啦,请看~~

F[i]表示选择这个结点的最优值;G[i]表示不选择这个结点的最优值;S[i]表示这个结点原来的权值.

• 对于叶子来说,F[i]=S[i],G[i]=0;
• 对于非叶子,
  • F[i]=∑G[j] +S[i]
  • G[i]=∑max(F[j],G[j])

  其中,j是i儿子~

• r为根,该树的结果就是max(F[r],G[r])啦^^

问题是….菜鸟的我不知道怎么构建树….看了例程,是C++写的,而且用了指针….好吧,看不懂.没办法…..还是硬着头皮自己想怎么去构建吧.

想啊想,想啊想,想到啦!!
想到建立一个二维数组T[i,j,k],i表示层数,j表示这一层的老爸,k肯定就是这个老爸的儿子们啦.按照宽度优先的规则将结点存进去就是了….
不过,在实际编程的时候,运用了深搜来建造这颗树,结合上面说的思路,发现从最低层开始,访问每个结点,顺便计算….这样,就不用记录下这颗树了,也就不用开数组来存它啦^^
这个可能是最笨的方法吧?….

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

program shopping;
type style=record //突然发现,记录类型太好用了…
             F,G,S:longint; //F:选择该结点的最优值;G:不选择该结点的最优值;S:该结点原来的权值.
             son:array[0..1000] of longint; //该结点的儿子们~
             used:boolean; //该结点是否被访问过
           end;
 
var thing:array[1..1000] of style; //商品
    k,m,i,temp,a,b,ans:longint;
 
function max(a,b:longint):longint;
begin
  if a>b then max:=a else max:=b;
end;
 
procedure get(l,f:longint); //建造树,并顺便算最优值
var i:longint;
begin
  if thing[f].used or (thing[f].son[0]=0) then begin //如果该结点已被访问过或他没有儿子
    thing[f].F:=thing[f].S;
    thing[f].used:=true;
    exit;
  end;
  thing[f].used:=true;
  for i:=1 to thing[f].son[0] do get(l+1,thing[f].son[i]); //对每个儿子构造一次
  thing[f].F:=thing[f].S;
  for i:=1 to thing[f].son[0] do begin //顺便计算每个结点的最优值
    thing[f].F:=thing[f].F+thing[thing[f].son[i]].G; //F[i]=∑G[j] +S[i]
    thing[f].G:=thing[f].G+max(thing[thing[f].son[i]].F,thing[thing[f].son[i]].G); //G[i]=∑max(F[j],G[j])
  end;
end;
 
begin
  assign(input,'shopping.in');assign(output,'shopping.out');
  reset(input);rewrite(output);
  readln(k,m);
  fillchar(thing,sizeof(thing),0);
  for i:=1 to k do begin
    fillchar(thing[i].son,sizeof(thing[i].son),0);
    readln(thing[i].S);
  end;
  for i:=1 to m do begin //帮老爸找到儿子
    readln(a,b);
    if a>b then begin //为避免重复,不能同时购买的商品中,编号小的是老爸
      temp:=a;a:=b;b:=temp;
    end;
    inc(thing[a].son[0]);
    thing[a].son[thing[a].son[0]]:=b;
  end;
 
  ans:=0;
  for i:=1 to k do //枚举每棵树
    if thing[i].used=false then begin
      get(1,i); //造树+计算最优值..
      ans:=ans+max(thing[i].F,thing[i].G); //累加最优值
    end;
 
  writeln(ans);
  close(input);close(output);
end.

You may like these posts:

• 《分组游戏》解题报告 (0)
• 《可怜的绵羊问题》解题报告 (0)
• 《直角三角形计数问题》解题报告 (3)
• USACO刷题记录 (73)
• GDOI2008,GAME OVER (20)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/shopping-report.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

有一群人,他们之中任意两个人的关系是认识或不认识(当然,也可能出现A认识B而B不认识A的情况),现在需要你按照一定的规则将他们分成两组,分组的规则如下:

1. 每个人属于其中的一组;
2. 每组至少有一个人;
3. 同一组种任何一个人都认识该组中的其他人;
4. 两组的人数要尽可能的接近

这个任务可能有多个解,你只需要输出其中任意一个或者输出无解信息.

这题例程是用DP+集合的方法的,写了瞒长的….

我是用什么方法我自己都不知道….只是,这个思路MS很棒(自恋下..).当然,基本思想还是有滴,是集合啦.

• 读完数据,也就是每个人的关系后,创建两个集合A、B(不是真的集合类型,是两个数组….).A[0](B[0])记录集合元素的个数.
• 然后把第一个人仍进集合A.
• 接着按照以下规则依次把人扔进集合中:
  • 若此人与A中任何一个人都认识,仍进A中;
  • 否则,若此人与B中任何一个人都认识,仍进B中;
  • 否则,输出无解,结束程序.

这样就保证了两个集合中人员编号的有序(输出要求..),同时也可以及时判断无解.这样有一个问题,就是无法满足条件4:两组的人数要尽可能的接近.

这个问题嘛,也不难.使A为人数多的集合,B为人数少的.每次从A中抽出B中任何一个人都认识的人插入到B中直到两个集合人数相等或不能再A中不能再向B插入任何人.

KO.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

program group;
const mp{maxpeople}=1000;
var g1,g2,tg:array[0..mp] of integer;
//g1=集合A,g2=集合B,tg=处理条件4时的中间变量
    re{relation}:array[1..mp,1..mp] of boolean;
    n,i,j,k,temp:integer;
    check,swap:boolean;
 
begin
  assign(input,'group.in');assign(output,'group.out');
  reset(input);rewrite(output);
  readln(n);
  if n=2 then begin
  //如果是2个人….想都别想,理他3721,答案肯定是这样的..
    writeln('1 1');
    writeln('1 2');
    close(input);close(output);
    halt;
  end;
  fillchar(re,sizeof(re),false);
  for i:=1 to n do begin
    read(j);
    while j<>0 do begin
      re[i,j]:=true;
      read(j);
    end;
    readln;
  end;
  fillchar(g1,sizeof(g1),0);
  g2:=g1;
  g1[0]:=1;g1[1]:=1; //将第一个人仍进集合A
 
  for i:=2 to n do begin //依次将人扔进集合中
    check:=true;
    for j:=1 to g1[0] do
      if (re[i,g1[j]]=false) or (re[g1[j],i]=false) then begin
      //如果和A中某个人不认识
        check:=false;
        break;
      end;
    if check then begin
    //如果和A中任何一个人都认识,扔进集合A中
      inc(g1[0]);
      g1[g1[0]]:=i;
    end
    else begin
    //否则,判断下是否和B中的任何一个人都人之
      for j:=1 to g2[0] do
        if (re[i,g2[j]]=false) or (re[g2[j],i]=false) then begin
        //惨了….和B中的某个人不认识.好吧,此题无解
          writeln('No solution');
          close(input);close(output);
          halt;
        end;
      //都认识噢?扔进集合B中..
      inc(g2[0]);
      g2[g2[0]]:=i;
    end;
  end;
 
  if g1[0]<g2[0] then begin
  //使A为人数多的集合,B为人数少的
    tg:=g1;g1:=g2;g2:=tg;
  end;
  if g1[0]=g2[0] then swap:=false else swap:=true;
  //如果两个集合人数相等,就不用再处理什么啦啦..
 
  while (g1[0]>g2[0]) and swap do begin
  //处理条件4
    temp:=g1[0];
  for i:=1 to g1[0] do begin
  //枚举A中的每个元素
      check:=true;
      for j:=1 to g2[0] do
        if (re[g1[i],g2[j]]=false) or (re[g2[j],g1[i]]=false) then begin
        //如果和B中某个人不认识,那就不能把他T出去了
          check:=false;
          break;
        end;
        if check then begin
        //如何条件,他被无情的T过去了
          for j:=1 to g2[0] do
            if g1[i]<g2[j] then begin
            //保证有序,把他插进去..
              for k:=j to g2[0] do g2[k+1]:=g2[k];
              g2[j]:=g1[i];
              inc(g2[0]);
              break;
            end;
          for k:=i to g1[0] do g1[k]:=g1[k+1];
          g1[k]:=0;
          dec(g1[0]);
          break;
        end;
      end;
    if g1[0]=temp then swap:=false;
    //说明集合A中没有任何人给T出去了,也就是不用再T人了…
  end;
 
  for i:=0 to g1[0]-1 do write(g1[i],' ');
  writeln(g1[g1[0]]);
  for j:=0 to g2[0]-1 do write(g2[j],' ');
  writeln(g2[g2[0]]);;
  close(input);close(output);
end.

You may like these posts:

• 《购物问题》解题报告 (3)
• 《可怜的绵羊问题》解题报告 (0)
• 《直角三角形计数问题》解题报告 (3)
• USACO刷题记录 (73)
• GDOI2008,GAME OVER (20)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/group-report.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

忽略无聊的故事性描述….直接写上这个问题的本质吧。实质上，这道题是这样的：

按逆时针顺序给出n个点（类型A）的坐标，这些点顺次相连成一个凸多边形（该多边形只是形状是凸的，即某些点可能落在多边形边上）。还给出一些点（类型B）的坐标，这些点可能在平面任何一个地方，当然，不与类型A的点重合。

你的任务是选出一些类型A的点围成一个新的凸多边形，并使它不包含类型B的点（类型B的点可以在边上）且面积尽可能的大。如果无法找到这样的多边形，则输出”die”;否则输出最大面积（保留两位小数）。

进一步浓缩题目可得出，本题的实质是在凸多边形内求一面积最大的新的凸多边形，且该多边形内无点。

如果以点u为起点，可以找到一个最大凸n边形VuV1V2…Vn，这个多边形以点n为尾且n与u相连；则凸n＋1边形也必是以u为起点，n＋1为尾的最大凸多边形。由此可见，此题满足最优化原理，可用动态规划解决。

如何划分状态呢？
我是将多边形划分成三角形的，从3个点开始，每次加一个点，即加一个三角形，原图形的面积加上新加三角形的面积即为此次的状态。

综上便可得出状态转移方程：

ms[u,j]=max{ms[u,i]+s(u,i,j)}(0<u<=n,u<i<j<n+u-1);

此方程中，u是枚举起点，i、j是往后的2个点(这两点不一定是连续的,因为某些点是不会成为新凸多边形的顶点的,要枚举忽略掉).

但是,这样还不算完成.还有一个条件,新凸多边形中不包含类型B的点.这条的实现要有数学的基础了(好吧,我承认,我是G出来的公式…)….
首先,用下面这条公式来计算三角形的面积(其实我也不知道是怎么得到的..):
公式一:

s=abs((x1*y2+x2*y3+x3*y1-x1*y3-x2*y1-x3*y2)/2)

用下面这条公式来判断点是否在直线上,成立则在.(高中数学必修一的内容了.~)
公式二:

(x1-x)*(y2-y)=(x2-x)*(y1-y)

判断点是否在三角形内的方法:
计算每条边和这个点组成的三个三角形的面积之和,若等于原三角形面积,则点在三角形上(用公式二排除掉)或三角形内;不等于则说明点在三角形外.
这样一来,就不难得出,最后的状态转移方程是这样的:

ms[u,j]=max{
      s(u,i,j) //边上有类型B的点
      ms[i]+s(u,i,j) //边上无类型B的点
      }

其中, 0 < u <= n, u < i < j < n+u-1,三角形VuViVj内无类型B的点.

说得不清楚?或许….你可以直接读源代码….

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

program sheep;
type map=record //记录点坐标的记录类型
     x,y:longint;
   end;
 
var p:array[1..300] of map;
 //前100个为类型A的点;为了枚举起点需要,中间100个同前100个一摸一样;后100个为类型B的点
   n,m,i,j,u:longint;
   ms:array[0..100,0..200] of real; //保存状态
   ts:real;
 
function gets(a,b,c:longint):real;
//计算三角形面积
begin
gets:=abs((p[a].x*p[b].y+p[b].x*p[c].y+p[c].x*p[a].y-p[a].x*p[c].y-p[b].x*p[a].y-p[c].x*p[b].y)/2);
end;
 
function checkside(a,b:longint):boolean;
//检查边上是否有类型B的点,有则返回true;
var d:longint;
begin
  checkside:=false;
  for d:=201 to m+200 do
    if (p[a].x-p[d].x)*(p[b].y-p[d].y)=(p[b].x-p[d].x)*(p[a].y-p[d].y) then begin
      checkside:=true;
      break;
    end;
end;
 
function cside(a,b,d:longint):boolean;
//为方便在检查三角形边上是否有点而在上一个函数的基础上增加一个参数
begin
  cside:=false;
  if (p[a].x-p[d].x)*(p[b].y-p[d].y)=(p[b].x-p[d].x)*(p[a].y-p[d].y) then
    cside:=true;
end;
 
function checkin(a,b,c:longint):boolean;
//检查三角形内是否有点,有则返回true
var d:longint;
begin
  checkin:=false;
  for d:=201 to m+200 do
    if (gets(a,b,c)=gets(a,b,d)+gets(a,c,d)+gets(b,c,d)) and (cside(a,b,d)=false) then begin
      checkin:=true;
      break;
    end;
end;
 
function max(a,b:real):real;
begin
  if a>b then max:=a else max:=b;
end;
 
begin
  assign(input,'sheep.in');
  assign(output,'sheep.out');
  reset(input);rewrite(output);
  readln(n);
  for i:=1 to n do begin
    readln(p[i].x,p[i].y);
    p[i+n].x:=p[i].x;p[i+n].y:=p[i].y;
  end;
  readln(m);
  for i:=1 to m do
    readln(p[i+200].x,p[i+200].y);
  fillchar(ms,sizeof(ms),0);
 
  for u:=1 to n do
  //枚举起点
    for i:=u+1 to n+u-1 do
    //枚举起点以后的另一个点
      for j:=i+1 to n+u-1 do
      //枚举新增的点
        if checkin(u,i,j)=false then begin
        //如果三角形内无点,则可加入此三角形到多边形中
          ts:=gets(u,i,j);
          if checkside(u,j) then ms[u,j]:=max(ms[u,j],ts)
          else ms[u,j]:=max(ms[u,j],ms[u,i]+ts);
        end;
 
  ts:=0;
  for u:=1 to n do
  //寻找枚举顶点得到的面积最大的多边形
    if ms[u,n+u-1]>ts then ts:=ms[u,n+u-1];
  if ts=0 then writeln('die') else writeln(ts:0:2);
  close(input);close(output);
end.

You may like these posts:

• 《购物问题》解题报告 (3)
• 《分组游戏》解题报告 (0)
• 《直角三角形计数问题》解题报告 (3)
• USACO刷题记录 (73)
• GDOI2008,GAME OVER (20)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/sheep-report.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

Applications generated by Free Pascal might generate Run-time error when certain abnormal conditions
are detected in the application. This appendix lists the possible run-time errors and gives
information on why they might be produced.

• 1 Invalid function number An invalid operating system call was attempted.
• 2 File not found Reported when trying to erase, rename or open a non-existent file.
• 3 Path not found Reported by the directory handling routines when a path does not exist or is invalid.
  Also reported when trying to access a non-existent file.
• 4 Too many open files The maximum number of currently opened files by your process has been
  reached. Certain operating systems limit the number of files which can be opened concurrently,
  and this error can occur when this limit has been reached.
• 5 File access denied Permission accessing the file is denied. This error might be caused by several
  reasons:
  • Trying to open for writing a file which is read only, or which is actually a directory.
  • File is currently locked or used by another process.
  • Trying to create a new file, or directory while a file or directory of the same name already
    exists.
  • Trying to read from a file which was opened in write only mode.
  • Trying to write from a file which was opened in read only mode.
  • Trying to remove a directory or file while it is not possible.
  • No permission to access the file or directory.
• 6 Invalid file handle If this happens, the file variable you are using is trashed; it indicates that your
  memory is corrupted.
• 12 Invalid file access code Reported when a reset or rewrite is called with an invalid FileMode
  value.
• 15 Invalid drive number The number given to the Getdir or ChDir function specifies a nonexistent
  disk.
• 16 Cannot remove current directory Reported when trying to remove the currently active directory.
• 17 Cannot rename across drives You cannot rename a file such that it would end up on another
  disk or partition.
• 100 Disk read error An error occurred when reading from disk. Typically when you try to read past
  the end of a file.
• 101 Disk write error Reported when the disk is full, and you’re trying to write to it.
• 102 File not assigned This is reported by Reset, Rewrite, Append, Rename and Erase, if
  you call them with an unassigned file as a parameter.
• 103 File not open Reported by the following functions : Close, Read, Write, Seek, EOf,
  FilePos, FileSize, Flush, BlockRead, and BlockWrite if the file is not open.
• 104 File not open for input Reported by Read, BlockRead, Eof, Eoln, SeekEof or SeekEoln
  if the file is not opened with Reset.
• 105 File not open for output Reported by write if a text file isn’t opened with Rewrite.
• 106 Invalid numeric format Reported when a non-numeric value is read from a text file, when a numeric value was expected.
• 150 Disk is write-protected (Critical error)
• 151 Bad drive request struct length (Critical error)
• 152 Drive not ready (Critical error)
• 154 CRC error in data (Critical error)
• 156 Disk seek error (Critical error)
• 157 Unknown media type (Critical error)
• 158 Sector Not Found (Critical error)
• 159 Printer out of paper (Critical error)
• 160 Device write fault (Critical error)
• 161 Device read fault (Critical error)
• 162 Hardware failure (Critical error)
• 200 Division by zero The application attempted to divide a number by zero.
• 201 Range check error If you compiled your program with range checking on, then you can get
  this error in the following cases:
  1. An array was accessed with an index outside its declared range.
  2. Trying to assign a value to a variable outside its range (for instance an enumerated type).
• 202 Stack overflow error The stack has grown beyond its maximum size (in which case the size of
  local variables should be reduced to avoid this error), or the stack has become corrupt. This
  error is only reported when stack checking is enabled.
• 203 Heap overflow error The heap has grown beyond its boundaries. This is caused when trying
  to allocate memory exlicitly with New, GetMem or ReallocMem, or when a class or object
  instance is created and no memory is left. Please note that, by default, Free Pascal provides a
  growing heap, i.e. the heap will try to allocate more memory if needed. However, if the heap
  has reached the maximum size allowed by the operating system or hardware, then you will get
  this error.
• 204 Invalid pointer operation This you will get if you call Dispose or Freemem with an invalid
  pointer (notably, Nil)
• 205 Floating point overflow You are trying to use or produce too large real numbers.
• 206 Floating point underflow You are trying to use or produce too small real numbers.
• 207 Invalid floating point operation Can occur if you try to calculate the square root or logarithm
  of a negative number.
• 210 Object not initialized When compiled with range checking on, a program will report this error
  if you call a virtual method without having called istr constructor.
• 211 Call to abstract method Your program tried to execute an abstract virtual method. Abstract
  methods should be overridden, and the overriding method should be called.
• 212 Stream registration error This occurs when an invalid type is registered in the objects unit.
• 213 Collection index out of range You are trying to access a collection item with an invalid index
  (objects unit).
• 214 Collection overflow error The collection has reached its maximal size, and you are trying to
  add another element (objects unit).
• 215 Arithmetic overflow error This error is reported when the result of an arithmetic operation is
  outside of its supported range. Contrary to Turbo Pascal, this error is only reported for 32-bit
  or 64-bit arithmetic overflows. This is due to the fact that everything is converted to 32-bit or
  64-bit before doing the actual arithmetic operation.
• 216 General Protection fault The application tried to access invalid memory space. This can be
  caused by several problems:
  1. Deferencing a nil pointer
  2. Trying to access memory which is out of bounds (for example, calling move with an
  invalid length).
• 217 Unhandled exception occurred An exception occurred, and there was no exception handler
  present. The sysutils unit installs a default exception handler which catches all excpetions
  and exits gracefully.
• 219 Invalid typecast Thrown when an invalid typecast is attempted on a class using the as operator.
  This error is also thrown when an object or class is typecast to an invalid class or object and
  a virtual method of that class or object is called. This last error is only detected if the -CR
  compiler option is used.
• 223 Threads not supported Thread management relies on a separate driver on some operating systems
  (notably, unixes). The unit with this driver needs to be specified on the uses clause of the
  program, preferably as the first unit. (cthreads on unix)
• 227 Assertion failed error An assertion failed, and no AssertErrorProc procedural variable
  was installed.

You may like these posts:

• Nemiver：图形化的 C/C++ 调试器 (0)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/free-pascal-run-time-errors.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

一个由大写字母组成的方阵里可能包含有一些等腰直角三角形(由同一种大写字母组成).你的任务就是写一个程序来统计方阵中由各种字母组成的等腰直角三角形的数目,以及等腰直角三角形的总数.

方阵中的等腰直角三角形只有下面两种情况:
(1) 两条直角边分别跟方阵的边平行,例如:

AAA AA A

B BB BBB

(2) 斜边与方阵的边平行,例如:

—A –AAA AAAAA

B BB BBB BB B

模拟题,很烦的模拟题….测的是你思维的严谨程度吧..

枚举每个点,每个点有8个拓展规则,实际上就是这个点向8个方向可形成的等腰直角三角形的个数.最后累加即可.

编起来是很繁琐的..直接看+了注释的代码吧.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

program triangle
var n,i,j,all:longint;
//这些变量分别是:方阵大小、2个枚举变量、总个数
    san:array[-1000..1000,-1000..1000]of char;
//方阵信息,为了方便(其实是偷懒….),范围定了个夸张的..
    tot:array['A'..'Z'] of longint;
//各个字母组成等腰直角三角形的个数
    m:char; //输出使用
 
procedure goon1(i,j,t:longint);
var m:longint;
begin
  if san[i,j+t]<>san[i,j] then exit;
//右边是否与中心相同
  if san[i+t,j]<>san[i,j] then exit;
//下面是否与中心相同
  for m:=0 to t do
    if san[i+m,j+t-m]<>san[i,j] then exit;
//斜边是否与中心相同
  inc(tot[san[i,j]]);inc(all);
  goon1(i,j,t+1);
//其实不需要递归的….外+一个for循环就可以搞定了
end;
 
procedure goon2(i,j,t:longint);
var m:longint;
begin
  if san[i,j-t]<>san[i,j] then exit;
  if san[i+t,j]<>san[i,j] then exit;
  for m:=0 to t do
    if san[i+m,j-t+m]<>san[i,j] then exit;
  inc(tot[san[i,j]]);inc(all);
  goon2(i,j,t+1);
end;
 
procedure goon3(i,j,t:longint);
var m:longint;
begin
  if san[i,j+t]<>san[i,j] then exit;
  if san[i-t,j]<>san[i,j] then exit;
  for m:=0 to t do
    if san[i-m,j+t-m]<>san[i,j] then exit;
  inc(tot[san[i,j]]);inc(all);
  goon3(i,j,t+1);
end;
 
procedure goon4(i,j,t:longint);
var m:longint;
begin
  if san[i,j-t]<>san[i,j] then exit;
  if san[i-t,j]<>san[i,j] then exit;
  for m:=0 to t do
    if san[i-m,j-t+m]<>san[i,j] then exit;
  inc(tot[san[i,j]]);inc(all);
  goon4(i,j,t+1);
end;
 
procedure goon5(i,j,t:longint);
var m:longint;
begin
  for m:=0 to (t*2+1) div 2 do begin
    if san[i+t,j-m]<>san[i,j] then exit;
    if san[i+t,j+m]<>san[i,j] then exit;
  end;
  inc(tot[san[i,j]]);inc(all);
  goon5(i,j,t+1);
end;
 
procedure goon6(i,j,t:longint);
var m:longint;
begin
  for m:=0 to (t*2+1) div 2 do begin
    if san[i-t,j-m]<>san[i,j] then exit;
    if san[i-t,j+m]<>san[i,j] then exit;
  end;
  inc(tot[san[i,j]]);inc(all);
  goon6(i,j,t+1);
end;
 
procedure goon7(i,j,t:longint);
var m:longint;
begin
  for m:=0 to (t*2+1) div 2 do begin
    if san[i-m,j+t]<>san[i,j] then exit;
    if san[i+m,j+t]<>san[i,j] then exit;
  end;
  inc(tot[san[i,j]]);inc(all);
  goon7(i,j,t+1);
end;
 
procedure goon8(i,j,t:longint);
var m:longint;
begin
  for m:=0 to (t*2+1) div 2 do begin
    if san[i-m,j-t]<>san[i,j] then exit;
    if san[i+m,j-t]<>san[i,j] then exit;
  end;
  inc(tot[san[i,j]]);inc(all);
  goon8(i,j,t+1);
end;
 
 
procedure search(i,j:longint);
//进行枚举搜索
begin
  if (j<>n) and (i<>n) then
//直角边与方阵边平行,右下
    if (san[i,j+1]=san[i,j]) and (san[i+1,j]=san[i,j]) then begin
      inc(tot[san[i,j]]);inc(all); //累计
      goon1(i,j,2);
//其实是没必要的….可以直接就写在这里的.下同
    end;
 
  if (j<>1) and (i<>n) then
//直角边与方阵边平行,左下
    if (san[i,j-1]=san[i,j]) and (san[i+1,j]=san[i,j]) then begin
      inc(tot[san[i,j]]);inc(all);
      goon2(i,j,2);
    end;
 
  if (j<>n) and (i<>1) then
//直角边与方阵边平行,右上
    if (san[i-1,j]=san[i,j]) and (san[i,j+1]=san[i,j]) then begin
      inc(tot[san[i,j]]);inc(all);
      goon3(i,j,2);
    end;
 
  if (j<>1) and (i<>1) then
//直角边与方阵边平行,左上
    if (san[i-1,j]=san[i,j]) and (san[i,j-1]=san[i,j]) then begin
      inc(tot[san[i,j]]);inc(all);
      goon4(i,j,2);
    end;
 
  if (i<>n) and (j<>1) and (j<>n) then
//斜边与方阵边平行,朝上
    if (san[i+1,j-1]=san[i,j]) and (san[i+1,j]=san[i,j]) and (san[i+1,j+1]=san[i,j]) then begin
      inc(tot[san[i,j]]);inc(all);
      goon5(i,j,2);
    end;
 
  if (i<>1) and (j<>n) and (j<>1) then
//斜边与方阵边平行,朝下
    if (san[i-1,j-1]=san[i,j]) and (san[i-1,j]=san[i,j]) and (san[i-1,j+1]=san[i,j]) then begin
      inc(tot[san[i,j]]);inc(all);
      goon6(i,j,2);
    end;
 
  if (i<>1) and (i<>n) and (j<>n) then
//斜边与方阵边平行,朝右
    if (san[i-1,j+1]=san[i,j]) and (san[i,j+1]=san[i,j]) and (san[i+1,j+1]=san[i,j]) then begin
      inc(tot[san[i,j]]);inc(all);
      goon7(i,j,2);
    end;
 
 
  if (i<>1) and (i<>n) and (j<>1) then
//斜边与方阵边平行,朝左
    if (san[i-1,j-1]=san[i,j]) and (san[i,j-1]=san[i,j]) and (san[i+1,j-1]=san[i,j]) then begin
      inc(tot[san[i,j]]);inc(all);
      goon8(i,j,2);
    end;
 
end;
 
begin
  assign(input,'triangle.in');
  assign(output,'triangle.out');
  reset(input);rewrite(output);
  readln(n);  all:=0;
  fillchar(tot,sizeof(tot),0);
  fillchar(san,sizeof(san),' ');
  for i:=1 to n do begin
    for j:=1 to n do
      read(san[i,j]);
    readln;
  end;
  for i:=1 to n do begin
    for j:=1 to n do begin
      search(i,j);
//对每个位置进行枚举搜索
    end;
  end;
  writeln(all);
  for m:='A' to 'Z' do writeln(m,' ',tot[m]);
  close(input);
  close(output);
end.

You may like these posts:

• 《购物问题》解题报告 (3)
• 《分组游戏》解题报告 (0)
• 《可怜的绵羊问题》解题报告 (0)
• USACO刷题记录 (73)
• GDOI2008,GAME OVER (20)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/triangle-report.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

GDOI,7月5日至7月8日.参赛权未定,争取中. 2008-06-13 17:24
已定.GDOI,I AM COMING!!

除OI,一切事情,暂停.当然,要是久等的机会出现,不会放过. 2008-06-13 17:27

Sky-Blue_L,直接应用.短时间内不再有时间修改. 2008-06-13 17:28

You may like these posts:

• 如何在主题中集成 ＠reply (14)
• 新主题—-Garland (17)
• GDOI2008,GAME OVER (20)
• 7.4-7.8,GDOI2008 (3)
• 《购物问题》解题报告 (3)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/is-time-to-be-busy.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

本人笔拙,写得不好..仅记我解题时的思路.如有不对或不足之处,望不吝赐教,谢谢^^
如有幸给您提供了帮助,不甚荣幸>.<
若有赐教或疑问,欢迎留言 or email我^^
My Email: wzf277028527 {at} gmail.com
其他联系方式:点我^^
P.S.:由于主题过滤缩进的空格,所以源代码中的空格均以下划线(”_”)代替~
已启用coolcode插件.
改用WP-Syntax

目录

• No.1 apple
• No.2 tree
• No.3 medic
• No.4 circle

• No.1 apple

很好很强大很和谐的一道超级模拟题。.
读入身高时+上30，apple数组中比它大的KO掉。

源代码:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

program apple; var a:array[1..10] of integer; tt,get,i:integer;   begin assign(input,'apple.in');assign(output,'apple.out'); reset(input);rewrite(output); for i:=1 to 10 do read(a[i]); readln; readln(tt); inc(tt,30); get:=0; for i:=1 to 10 do if tt>=a[i] then inc(get); writeln(get); close(input);close(output); end.

返回目录

• No.2 tree

  又是很好很强大很和谐的一道超级模拟题。
  用trees[boolean]表示树还在不在….读入数据的时候顺便就把施工段的树给false掉，最后数数true的个数就OK了

  源代码:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  program tree; var l,m,left,i,j,x,y:longint; trees:array[0..10000] of boolean;   begin assign(input,'tree.in');assign(output,'tree.out'); reset(input);rewrite(output); readln(l,m); fillchar(trees,sizeof(trees),1); for i:=1 to m do begin readln(x,y); for j:=x to y do trees[j]:=false; end; j:=0; for i:=0 to l do if trees[i] then inc(j); writeln(j); close(input);close(output); end.

  返回目录

• No.3 medic

  又是0/1背包问题….
  wi为时间，vi为价值。

  • V[i,j]=0(若i=0或j=0)
  • V[i,j]=V[i-1,j](若j<wi)
  • V[i,j]=max{V[i-1,j]，V[i-1，j-wi]+vi}(若i>0和j≥wi)

源代码:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

program medic; var t,m,i,j:longint; v,w:array[1..1000] of longint; f:array[0..100,0..1000] of longint;   begin assign(input,'medic.in');assign(output,'medic.out'); reset(input);rewrite(output); readln(t,m); for i:=1 to m do readln(w[i],v[i]); fillchar(f,sizeof(f),0); for i:=1 to m do for j:=1 to t do if f[i-1,j]<f[i-1,j-w[i]]+v[i] then f[i,j]:=f[i-1,j] else f[i,j]:=f[i-1,j-w[i]]+v[i]; writeln(f[m,t]); close(input);close(output); end.

返回目录

• No.4 circle

显然，考察的是高精度加法。但是,我还不会做….

源代码:

1 2 3

program circle;   waiting..

返回目录

You may like these posts:

• NOIP2006普及组 解题报告 (2)
• NOIP2005 fire 解题报告 (1)
• NOIP2006 energy 解题报告 (0)
• NOIP2005 equal 解题报告 (0)
• NOIP2007 矩阵取数游戏 解题报告 (4)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/noip2005-junior.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

本人笔拙,写得不好..仅记我解题时的思路.如有不对或不足之处,望不吝赐教,谢谢^^
如有幸给您提供了帮助,不甚荣幸>.<
若有赐教或疑问,欢迎留言 or email我^^
My Email: wzf277028527 {at} gmail.com
其他联系方式:点我^^
P.S.:由于主题过滤缩进的空格,所以源代码中的空格均以下划线(”_”)代替~
已启用coolcode插件.
改用WP-Syntax

目录

• No.1 random
• No.2 happy
• No.3 count
• No.4 sequence

• No.1 random

在读入数据的时候顺便查重，然后qsort……KO.

源代码:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

program random; type arr=array[1..1000] of longint; var n,temp,i,j:longint; num:arr; check:array[1..1000] of boolean;   procedure sort(l,r:longint); var i,j,mid,temp:longint; begin i:=l;j:=r;mid:=num[(l+r) div 2]; repeat while num[i]<mid do inc(i); while num[j]>mid do dec(j); if i<=j then begin temp:=num[i];num[i]:=num[j];num[j]:=temp; inc(i);dec(j); end; until i>j; if i<r then sort(i,r); if l<j then sort(l,j); end;   begin assign(input,'random.in');assign(output,'random.out'); reset(input);rewrite(output); readln(n); fillchar(check,sizeof(check),0); j:=0; for i:=1 to n do begin read(temp); if not check[temp] then begin inc(j); num[j]:=temp; check[temp]:=true; end; end; sort(1,j); writeln(j); for i:=1 to j-1 do write(num[i],' '); writeln(num[j]); close(input);close(output); end.

返回目录

• No.2 happy

  DP，经典的0/1背包问题。
  wi为价格，vi为价值。

  • 0(若i=0或j=0)
  • V[i,j]= V[i-1,j](若j< wi)
  • max{V[i-1,j]，V[i-1，j-wi]+vi}(若i>0和j≥wi)

源代码:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

program happy; var n,m,i,j,p:longint; f:array[0..30,0..100000] of longint; v,w:array[0..100000] of longint;   begin assign(input,'happy.in');assign(output,'happy.out'); reset(input);rewrite(output); readln(n,m); for i:=1 to m do begin readln(v[i],p); w[i]:=v[i]*p; end; fillchar(f,sizeof(f),0); for i:=1 to m do for j:=1 to n do if j<v[i] then f[i,j]:=f[i-1,j] else if f[i-1,j]>(f[i-1,j-v[i]]+w[i]) then f[i,j]:=f[i-1,j] else f[i,j]:=f[i-1,j-v[i]]+w[i]; writeln(f[m,n]); close(input);close(output); end.

返回目录

• No.3 count

先确定字母范围，然后从字符串后往前推，当推到可以+1的位置a，后面的顺次为前面的+1。最后注意输出。
BS最后一个点，超出数据范围了。

源代码:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

program count; var s,t,w,i,j,k:integer; sum,sumend:string; be,en,temp:char;   begin assign(input,'count.in');assign(output,'count.out'); reset(input);rewrite(output); readln(s,t,w); readln(sum); be:=chr(s-1+ord('a')); en:=chr(t-1+ord('a')); sumend:=''; for i:=1 to w do sumend:=chr(ord(en)-i+1)+sumend; i:=0; repeat for j:=w downto 1 do begin if chr(ord(sum[j])+w-j)<en then begin temp:=sum[j]; for k:=j to w do sum[k]:=chr(ord(temp)+k-j+1); inc(i); if i<=5 then writeln(sum); break; end; end; until (sum=sumend) or (i=5); close(input);close(output); end.

返回目录

• No.4 sequence

30	31	30+31	32	30+32	31+32	30+31+32	33
1	10	11	100	101	110	111	1000

看出点东西了吧～其实，就是一个二进制序列，每位对应一个幂，如：末位对应0次，次末尾对应1次……
这题的做法就这样了，将n转换为二进制，计算即可。

源程序:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

program sequence; var k,m,n,i,j,p,ans:longint;   begin assign(input,'sequence.in');assign(output,'sequence.out'); reset(input);rewrite(output); readln(k,n); ans:=0;p:=1; repeat m:=n mod 2; n:=n div 2; ans:=ans+p*m; if n<>0 then p:=p*k; until n=0; writeln(ans); close(input);close(output); end.

返回目录

You may like these posts:

• NOIP2005普及组 解题报告 (4)
• NOIP2005 fire 解题报告 (1)
• NOIP2006 energy 解题报告 (0)
• NOIP2005 equal 解题报告 (0)
• NOIP2007 矩阵取数游戏 解题报告 (4)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/noip2006-junior.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

题意理解错误。得分：0；

这题的b1，b2…..bm可以跳着来的….faint..

参照薛原的做法：

先构造出2个“1”开头的目标状态，然后顺次移动0～n-1与{1,2,3,….n}比较，min(不同的个数)即为所求。时间复杂度为O(n^2)….对于50000的数据，第4个点就超时了….

要加入适当的剪枝。

仔细研究发现，不必要真的去移动….可以算出这个点的数据移动k次后到达该到的点，那么此点是移动k次后不需交换的点，inc（num[k]）；即：

for i:=1 to n do inc(num[(sort[i]-i+n) mod n]);

对于2个目标状态做2次。如此以来，最后扫两遍num[0～n-1]得出最大值max，ans=n-max；

• 程序代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

program fire;
type arr=array[0..50000] of longint;
 
var n,i,min:longint;
      f:array[1..50000,1..2] of longint;
      sort1,sort2,num:arr;
      check:boolean=true;
 
procedure makefire(var sort:arr;m:integer);
var i,j:longint;
begin
   if m=1 then j:=2
   else j:=1;
   sort[1]:=1;sort[2]:=f[1,m];
   i:=2;
   repeat
      if f[sort[i],1]=sort[i-1] then begin
         inc(i);sort[i]:=f[sort[i-1],2]
      end
      else if f[sort[i],2]=sort[i-1] then begin
                inc(i);sort[i]:=f[sort[i-1],1]
             end
             else check:=false;
   until (i>=n) or (check=false);
   if f[1,j]<>sort[n] then check:=false;
end;
 
function getsort:longint;
var i,temp:longint;
begin
   if check then begin
      fillchar(num,sizeof(num),0);
      temp:=0;
      for i:=1 to n do inc(num[(sort1[i]-i+n) mod n]);
      for i:=0 to n-1 do if num[i]>temp then temp:=num[i];
      fillchar(num,sizeof(num),0);
      for i:=1 to n do inc(num[(sort2[i]-i+n) mod n]);
      for i:=0 to n-1 do if num[i]>temp then temp:=num[i];
      getsort:=n-temp;
   end
   else getsort:=-1;
end;
 
begin
   assign(input,'fire.in');assign(output,'fire.out');
   reset(input);rewrite(output);
   readln(n);
   for i:=1 to n do readln(f[i,1],f[i,2]);
   makefire(sort1,1);
   makefire(sort2,2);
   min:=getsort;
   writeln(min);
   close(input);close(output);
end.

You may like these posts:

• NOIP2005普及组 解题报告 (4)
• NOIP2006普及组 解题报告 (2)
• NOIP2006 energy 解题报告 (0)
• NOIP2005 equal 解题报告 (0)
• NOIP2007 矩阵取数游戏 解题报告 (4)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/noip2005-fire.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

做这道题目，分了三个阶段。

• 单纯的将题目的合并理解成一小颗一小颗的顺时针合并，过了样例，第一点，失败。
• 考虑到了合并顺序的问题，想法是分段合并，但每次只合并一个到大珠子里。仍只过了样例，第一点，失败。
• 发现原来每段可以合并成两颗大珠子再进一步合并。于是，修改方程。得出：

  f[i,j]:=max(f[i,j],f[i,k]+f[k+1,j]+data[i]*data[k+1]*data[j+1]);

  通过枚举段长L、起始位置i，可求出段终止位置j；再枚举断点k即可计算出每段的最大值。

还有一点吃亏了，就是，由于是链，所以数组开了2n。一开始i是从1到n，后面的计算却需要用到n到2n的数据（虽然和1到n的数据一样）..调整后，AC。

• 程序代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

program energy;
var n,i,j,k,l:integer;
      data:array[1..300] of longint;
      f:array[1..100,1..100] of longint;
      answer:longint;
 
function max(a,b:longint):longint;
begin
   if a>b then max:=a else max:=b;
end;
 
begin
   assign(input,'energy.in');assign(output,'energy.out');
   reset(input);rewrite(output);
   fillchar(data,sizeof(data),0);
   readln(n);
   for i:=1 to n do begin
      read(data[i]);
      data[i+n]:=data[i];data[i+n+n]:=data[i];
   end;
   readln;close(input);
   answer:=0;
   fillchar(f,sizeof(f),0);
   for l:=1 to n-1 do
      for i:=1 to 2*n-1 do begin
         j:=i+l;
         if j<2*n then
            for k:=i to j-1 do f[i,j]:=max(f[i,j],f[i,k]+f[k+1,j]+data[i]*data[k+1]*data[j+1]);
      end;
   for i:=1 to n do answer:=max(answer,f[i,i+n-1]);
   writeln(answer);
   close(output);
end.

You may like these posts:

• NOIP2005普及组 解题报告 (4)
• NOIP2006普及组 解题报告 (2)
• NOIP2005 fire 解题报告 (1)
• NOIP2005 equal 解题报告 (0)
• NOIP2007 矩阵取数游戏 解题报告 (4)

©2010 逆时. All Rights Reserved.

This article addresses:http://backtimer.missnkiss.com/noip2006-energy.html

本作品采用署名-非商业性使用-相同方式共享 3.0 许可协议进行许可。转载请注明出自逆时。

在纸上算了很久，才上机编写….编写很流畅..除去几个小bug，90分~满意了^_^

• 问题简述

给定一个带有一个位置数的带运算级（+,-,*,^)以及括号的算式，再给n个算式，判断n个里面与其相等的式子。输出序号（A,B,C….)。

• 解题分析

首先想到展开，不过，马上否决，编写起来实在太烦了。想到了产生随机数代值直接算。于是乎，此题就等于是模拟一个计算器出来。

由于题目要求到了优先级，在想了直接从左到右按括号递推、递归等无法实现的方法后，想到了N年前讲过的后序遍历。手算了几遍，掌握了普通式子变后序以及直接利用后序计算的方法后，开编。

录入式子的同时，过滤掉空格。求后序方法为：

procedure gettree(p,q);{p-q段为式子要转化的段}

if p=q 录入

else

从右到左搜索最低运算级别符号；

录入此符号。

递归右边；

递归左边。

最后转化的式子，由于已经没有括号以及优先级了，从左到右按照“两数一符号(即”123++”的计算顺序为：2+3=5,1+5=6)”的顺序过一遍，即可求出结果。多次重复求结果，即可滤掉错误的式子，准确率高。

最后结果：90分。

错于最后一个点，这个点代入10以内的数都会越界….

已解决。每步计算都取模一次即可….

• 程序代码

不知道为什么代码发不上来了…..提示如下：

Service Temporarily Unavailable

The server is temporarily unable to service your request due to maintenance downtime or capacity problems. Please try again later.

以附件的形式弄上来吧~~

附件：equal.pas

当我过了段时间….换了个主题,换了个空间….再尝试发布代码,会怎样?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

program equal;
const max=maxint;
 
type str=array[1..100] of string;
       arr=array[0..26] of str;
       int=int64;
 
var n,i,j,m,a:integer;
      ans,temp:int;
      tree,sumstr:arr;
      check:array[1..26] of boolean;
      signset:set of char=['+','-','*','^','(',')'];
      ended:array[0..26] of integer;
 
procedure readfile(q:integer);
var i,p:integer;
      temp:string;
      strtemp:string;
begin
   i:=1;p:=0;
   readln(strtemp);
   repeat
      if strtemp[i]=' ' then inc(i)
      else
         if strtemp[i] in signset then begin
            inc(p);
            sumstr[q][p]:=strtemp[i];
            inc(i);
         end
         else begin
            temp:='';
            repeat
               temp:=temp+strtemp[i];
               inc(i);
            until (strtemp[i]=' ') or (strtemp[i] in signset) or (i>length(strtemp));
            inc(p);
            sumstr[q][p]:=temp;
         end;
   until i>length(strtemp);
   ended[q]:=p;
end;
 
function grade(c:char):integer;
begin
   case c of
      '+','-':grade:=1;
      '*':grade:=2;
      '^':grade:=3;
      '(',')':grade:=4;
   end;
end;
 
function checked(sumstr:str;p,q:integer):boolean;
var i,level:integer;
begin
   level:=0;
   for i:=p to q do begin
      if sumstr[i]='(' then inc(level);
      if sumstr[i]=')' then dec(level);
      if (level=0) and (i<>q) then begin
         checked:=false;
         exit;
      end;
   end;
   checked:=true;
end;
 
procedure gettree(x:integer;var m:integer;p,q:integer);
var level,temp,levi,levtemp,i:integer;
      check:boolean;
begin
   if p=q then begin
      dec(m);
      tree[x][m]:=sumstr[x][p];
   end
   else begin
      check:=true;
      while (sumstr[x][p]='(') and (sumstr[x][q]=')') and check do begin
         check:=checked(sumstr[x],p,q);
         if check then begin
            inc(p);
            dec(q);
         end;
      end;
      level:=1000;levtemp:=1;
      for i:=q downto p do
         if sumstr[x][i][1] in signset then begin
            if sumstr[x][i][1]=')' then begin
               levtemp:=levtemp*5;
               continue;
            end;
            if sumstr[x][i][1]='(' then begin
               levtemp:=levtemp div 5;
               continue;
            end;
            temp:=grade(sumstr[x][i][1])+levtemp;
            if temp<level then begin
               level:=temp;
               levi:=i;
            end;
         end;
      dec(m);
      tree[x][m]:=sumstr[x][levi];
      gettree(x,m,levi+1,q);
      gettree(x,m,p,levi-1);
   end;
end;
 
function work(a,b : int;c:char):int;
var i:integer;
      temp:int;
begin
    temp:=1;
   case c of
      '+'	: temp:=(a+b) mod max;
      '-'	: temp:=(a-b) mod max;
      '*'	: temp:=a*b mod max;
      '^'	: for i:=1 to b do temp:=a*temp mod max;
   end; { case }
   work:=temp;
end;
 
function calc(x,a,p:integer):int;
var sum:array[1..100] of int;
      q,i,temp:integer;
begin
   q:=0;
   for i:=p to 100 do
      if tree[x][i][1] in signset then begin
         dec(q);
         sum[q]:=work(sum[q],sum[q+1],tree[x][i][1]);
      end
      else begin
         inc(q);
         if tree[x][i]='a' then sum[q]:=a else val(tree[x][i],sum[q],temp);
      end;
   calc:=sum[1];
end;
 
begin
   assign(input,'equal.in');assign(output,'equal.out');
   reset(input);rewrite(output);
   readfile(0);readln(n);
   for i:=1 to n do readfile(i);
   fillchar(check,sizeof(check),true);
   for j:=0 to n do begin
      m:=101;
      gettree(j,m,1,ended[j]);
      ended[j]:=m;
   end;
   randomize;
   for i:=1 to 5 do begin
      a:=random(10000);
      ans:=calc(0,a,ended[0]);
      for j:=1 to n do
         if check[j] then begin
            temp:=calc(j,a,ended[j]);
            if temp<>ans then check[j]:=false;
         end;
   end;
   for i:=1 to n do
      if check[i] then write(chr(64+i));
   writeln;
   close(input);close(output);
end.