C++博客-xunil's -文章分类-ACM

pku 初期刷题（from The Dec 3 until holiday begin ，the aim is 100+ ）

xunil — Thu, 03 Dec 2009 11:22:00 GMT

刷出一题，就加入这里！
总共100+！
期限是在寒假开始之前结束！

xunil 2009-12-03 19:22 发表评论

（ACM学习小段）总结

xunil — Wed, 02 Dec 2009 13:46:00 GMT

    自从上次去工大比赛回来，就是十分的不开心！而且决定要在下年一定要拿到奖牌，首先就是四省赛一等奖，然后就是亚洲区的，相信我是可以的！
    这段时间主要就是了解了下 RMQ ， LCA ，线段树，trie 树，然后就没什么了，这段时间也AC了几题，但是应该至少不算是那种十分水的水题，虽然也很水!但是我相信慢慢的所有的题都会变成水题！我等待那天的到来，自然我需要努力才能召唤出她来！
    为自己加油吧，最近学习的状态还是挺不错的！接下来，我想把这东西弄得清楚些，可不能半瓶子，那样可是不行的！
    还有决定把LRJ的那本书尽量的都过一遍，如果可以的话，做会里面的所有的题！虽然可能有点难!但是还是那句话，加油吧！一切皆有可能！
    我想看看，如果在放假前能不能刷出100道题！(现在AC 24 )呵呵呵！好像有点困难！just try it !

     ps（还有就是期待这个周末，呵呵，要和一个女生吃饭，我还想约她看电影，看看再说吧，希望顺利）

xunil 2009-12-02 21:46 发表评论

11.9 线段树 POJ 2528 Mayor's posters

xunil — Mon, 09 Nov 2009 15:42:00 GMT

看到了很多人说离散化，一开始不太明白到底是什么意思！直到昨天晚上看完了 poj 2528 染色问题
怎么说呢，个人觉得应该是把那些离散的点聚合吧，我们要把两个不相同的相邻的点的距离变成1，那么如果我们有一些列的点如：1 2 3 4 6 7 8 19 聚合化以后变成了，0 1 2 3 4 5 6 7，这就说我们把原来的大区间相同化为了小点的区间，前提这两个区间在某方面是等价的！

还有我个人一开始写的线段树，写的很差，根本没有发挥线段树的主要优点，所以一开始是TLE，我写的是对点操作了，而非对线段或者区间操作，所以完全没有发挥线段树的优点！很是不爽，自以为自己弄明白了线段树！还是得看看资料理解下！思考，这道题暂时留着不A了！

个人对离散话的理解是：把大区间转化成小区间！如果有什么错误的，望请告知！谢谢！

我要睡觉去了，先找个题看看，然后就睡觉去了！晚安！各位！

等我完全弄明白了线段树，再把这题的解题报告写出来！

一开始以为自己到底是怎么了，怎么搞不定这题呢，而且一开始TLE，这个我能理解，因为后来我才发现了，我处理的不是对线段处理的，而还是对点处理的，当然TLE ，然后我就仔细的看了下别人的代码，发现其实我们没有什么不同的，就只有聚合化（本人理解觉得不应该叫做离散话，如果你知道为什么叫做离散话请告诉我，虽然 lrj上的，火星地图，我觉得用离散化这个词倒是对，这里应该叫做聚合化，纯属个人理解！错误请指正！谢谢！）后涂色不一样，所以我TLE，我是：如果a-b区间要涂色，我就更新到每个的a-b之间的
点，这样肯定是不行的，还不如不用线段树，完全没有发挥，线段树区间的性质！这也说明，线段树我还没有学明白!

这里加上一个注意吧，个人理解一般来说，对线段树的操作，很少是到达叶子的！而是大部分对某一区间进行操作的！一定要记住这点，可别把线段树，当作数组来操作了，那就没有意义了！

下面是我的代码，是参考别人写的，个人觉得主要是 post() 函数，我一开始就是写错了，根本就没有理解和发挥线段树的效率，所以TLE！线段树的知识还是需要多加练习与学习！

#include<stdio.h>
#include<memory.h>
#include<algorithm>
#include<iostream>
using namespace std ;
#define N 10005

struct datanode
{
    int f , t ;
} datain[N] ;
int n ;    // the numbers of poster
int m ;    // the small area
int datasort[N*2] ;    // for smaller
int colornums ;    // the numbers of the end
int judge[N*2] ;    //    for judge the rest of color
struct tnode
{
    int from  , to ;
    int color ;    // the color from the area of "from" to "to" 0 no post , >= 1 is post color
} t[N*8] ;
void create( int st , int ed , int r )
{
    t[r].from = st ;
    t[r].to = ed ;
    t[r].color = 0 ;
    if( st == ed )
        return ;
    int mid = ( st + ed ) >> 1 ;
    create( st , mid , r *2 ) ;
    create( mid+1 , ed , r*2+1 ) ;
}

void post( int st , int ed , int c , int r )
{
    if( t[r].from == st && t[r].to == ed  )
    {
        t[r].color = c ;
        return ;
    }

    if( t[r].color != -1)
    {
        t[r*2].color = t[r].color ;
        t[r*2+1].color = t[r].color ;
        t[r].color = -1 ;
    }

    int mid = ( t[r].from + t[r].to ) >> 1 ;

    if( mid >= ed )
    {
        post( st ,ed , c , r * 2 ) ;
    }
    else if( mid < st )
    {
        post( st , ed , c , r*2+1 ) ;
    }
    else
    {
        post( st , mid , c , r * 2 ) ;
        post( mid+1 , ed , c , r *2 +1 ) ;
    }
}

int b_search( int k )
{
    int left = 0 , right = m - 1 ;
    int mid = ( left + right ) >> 1 ;
    while( k != datasort[mid] )
    {
        if( k < datasort[mid] )
        {
            right = mid -1 ;
        }
        else
        {
            left =  mid + 1 ;
        }
        mid = ( left + right ) >> 1 ;
    }
    return mid ;
}

void howmany( int r )
{
    if( t[r].color == -1)
    {
        howmany( r*2 ) ;
        howmany( r*2+1) ;
    }
    else
    {
        if( ! judge[ t[r].color ] )
        {
            //cout<
            colornums ++ ;
            judge[ t[r].color ] = 1 ;
        }
        return ;
    }
}

int main()
{
    int ntc ;
    int i , j ;
    scanf( "%d" , & ntc ) ;
    int ff , tt ;
    while( ntc --)
    {
        scanf( "%d" , & n ) ;
        for( i = 0 ; i< n ; i++ )
        {
            scanf( "%d%d" , & datain[i].f , & datain[i].t) ;
            datasort[i*2] = datain[i].f ;
            datasort[i*2+1] = datain[i].t ;
        }
        sort( datasort , datasort+(2*n) ) ;

        m = 1 ;
        for( j = 1 ; j< 2*n ; j++ )
        {
            if( datasort[j-1] != datasort[j] )
                datasort[m++] = datasort[j] ;
        }

        create( 0 , m-1 , 1 ) ;

        for( i = 0 ; i< n ; i++ )
        {
            ff = b_search( datain[i].f ) ;
            tt = b_search( datain[i].t ) ;
            post( ff , tt , i+1 , 1 ) ;
        }

        colornums = 0 ;
        memset( judge , 0 , sizeof( judge ) );
        judge[0] = 1 ;

        howmany( 1) ;

        printf("%d\n" , colornums ) ;
    }

    return 0 ;
}

xunil 2009-11-09 23:42 发表评论

lrj 黑书［目标是全切，时间暂时不定］

xunil — Fri, 06 Nov 2009 15:31:00 GMT

虽然现在以我的实力，这个完全是个梦想，但是我还是相信自己能完成！为自己加油！

1.DP
2.搜索
3.常用数据结构
.1线段树
.2树状数组
.3堆的应用
.4左偏树，二项式堆或其他可合并堆的应用
.5并查集
.6字典树
.7多串匹配树
.8后缀数组

4.图论

POJ上一些题目在
http://162.105.81.202/course/problemSolving/
可以找到解题报告。
《算法艺术与信息学竞赛》的习题提示在网上可搜到

一.动态规划
参考资料：
刘汝佳《算法艺术与信息学竞赛》
《算法导论》

推荐题目：
http://acm.pku.edu.cn/JudgeOnline/problem?id=1141
简单

http://acm.pku.edu.cn/JudgeOnline/problem?id=2288
中等，经典TSP问题

http://acm.pku.edu.cn/JudgeOnline/problem?id=2411
中等，状态压缩DP

http://acm.pku.edu.cn/JudgeOnline/problem?id=1112
中等

http://acm.pku.edu.cn/JudgeOnline/problem?id=1848
中等，树形DP。
可参考《算法艺术与信息学竞赛》动态规划一节的树状模型

http://acm.zju.edu.cn/show_problem.php?pid=1234
中等，《算法艺术与信息学竞赛》中的习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1947
中等，《算法艺术与信息学竞赛》中的习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1946
中等，《算法艺术与信息学竞赛》中的习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1737
中等，递推

http://acm.pku.edu.cn/JudgeOnline/problem?id=1821
中等，需要减少冗余计算

http://acm.zju.edu.cn/show_problem.php?pid=2561
中等，四边形不等式的简单应用

http://acm.pku.edu.cn/JudgeOnline/problem?id=1038
较难，状态压缩DP，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1390
较难，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=3017
较难，需要配合数据结构优化（我的题目^_^）

http://acm.pku.edu.cn/JudgeOnline/problem?id=1682
较难，写起来比较麻烦

http://acm.pku.edu.cn/JudgeOnline/problem?id=2047
较难

http://acm.pku.edu.cn/JudgeOnline/problem?id=2152
难，树形DP

http://acm.pku.edu.cn/JudgeOnline/problem?id=3028
难，状态压缩DP，题目很有意思

http://acm.pku.edu.cn/JudgeOnline/problem?id=3124
难

http://acm.pku.edu.cn/JudgeOnline/problem?id=2915
非常难

二.搜索
参考资料：
刘汝佳《算法艺术与信息学竞赛》
推荐题目：
http://acm.pku.edu.cn/JudgeOnline/problem?id=1011
简单，深搜入门题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1324
中等，广搜

http://acm.pku.edu.cn/JudgeOnline/problem?id=2044
中等，广搜

http://acm.pku.edu.cn/JudgeOnline/problem?id=2286
较难，广搜

http://acm.pku.edu.cn/JudgeOnline/problem?id=1945
难，IDA*，迭代加深搜索，需要较好的启发函数

http://acm.pku.edu.cn/JudgeOnline/problem?id=2449
难，可重复K最短路，A*。
可参考解题报告:
http://acm.pku.edu.cn/JudgeOnline/showcontest?contest_id=1144

http://acm.pku.edu.cn/JudgeOnline/problem?id=1190
难，深搜剪枝，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1084
难，《算法艺术与信息学竞赛》习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=2989
难，深搜

http://acm.pku.edu.cn/JudgeOnline/problem?id=1167
较难，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1069
很难

三. 常用数据结构
参考资料：
刘汝佳《算法艺术与信息学竞赛》
《算法导论》
线段树资料：
http://home.ustc.edu.cn/~zhuhcheng/ACM/segment_tree.pdf
树状数组资料
http://home.ustc.edu.cn/~zhuhcheng/ACM/tree.ppt
关于线段树和树状数组更多相关内容可在网上搜到
后缀数组资料
http://home.ustc.edu.cn/~zhuhcheng/ACM/suffix_array.pdf
http://home.ustc.edu.cn/~zhuhcheng/ACM/linear_suffix.pdf

推荐题目
http://acm.pku.edu.cn/JudgeOnline/problem?id=2482
较难，线段树应用，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1151
简单，线段树应用矩形面积并，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=3225
较难，线段树应用，可参考解题报告
http://acm.pku.edu.cn/JudgeOnline/showcontest?contest_id=1233

http://acm.pku.edu.cn/JudgeOnline/problem?id=2155
难，二维树状数组。

http://acm.pku.edu.cn/JudgeOnline/problem?id=2777
中等，线段树应用。

http://acm.pku.edu.cn/JudgeOnline/problem?id=2274
难，堆的应用，《算法艺术与信息学竞赛》中有解答

http://acm.zju.edu.cn/show_problem.php?pid=2334
中等，左偏树，二项式堆或其他可合并堆的应用。
左偏树参考http://www.nist.gov/dads/HTML/leftisttree.html
二项式堆参见《算法导论》相关章节

http://acm.pku.edu.cn/JudgeOnline/problem?id=1182
中等，并查集

http://acm.pku.edu.cn/JudgeOnline/problem?id=1816
中等，字典树

http://acm.pku.edu.cn/JudgeOnline/problem?id=2778
较难，多串匹配树
参考：http://home.ustc.edu.cn/~zhuhcheng/ACM/zzy2004.pdf

http://acm.pku.edu.cn/JudgeOnline/problem?id=1743
难，后缀数组

http://acm.pku.edu.cn/JudgeOnline/problem?id=2774
较难，最长公共子串，经典问题，后缀数组

http://acm.pku.edu.cn/JudgeOnline/problem?id=2758
很难，后缀数组
可参考解题报告
http://acm.pku.edu.cn/JudgeOnline/showcontest?contest_id=1178

http://acm.pku.edu.cn/JudgeOnline/problem?id=2448
很难，数据结构综合运用

四.图论基础
参考资料：
刘汝佳《算法艺术与信息学竞赛》
《算法导论》
《网络算法与复杂性理论》谢政

推荐题目:
http://acm.pku.edu.cn/JudgeOnline/problem?id=2337
简单，欧拉路

http://acm.pku.edu.cn/JudgeOnline/problem?id=3177
中等，无向图割边

http://acm.pku.edu.cn/JudgeOnline/problem?id=2942
较难，无向图双连通分支

http://acm.pku.edu.cn/JudgeOnline/problem?id=1639
中等，最小度限制生成树，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=2728
中等，最小比率生成树，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=3013
简单，最短路问题

http://acm.pku.edu.cn/JudgeOnline/problem?id=1275
中等，差分约束系统，Bellman-Ford求解，《算法艺术与信息学竞赛》中有解答

http://acm.pku.edu.cn/JudgeOnline/problem?id=1252
简单，Bellman-Ford

http://acm.pku.edu.cn/JudgeOnline/problem?id=1459
中等，网络流

http://acm.pku.edu.cn/JudgeOnline/problem?id=2391
较难，网络流

http://acm.pku.edu.cn/JudgeOnline/problem?id=1325
中等，二部图最大匹配

http://acm.pku.edu.cn/JudgeOnline/problem?id=2226
较难，二部图最大匹配

http://acm.pku.edu.cn/JudgeOnline/problem?id=2195
中等，二部图最大权匹配
KM算法参考《网络算法与复杂性理论》

http://acm.pku.edu.cn/JudgeOnline/problem?id=2516
较难，二部图最大权匹配

http://acm.pku.edu.cn/JudgeOnline/problem?id=1986
中等，LCA（最近公共祖先）问题
参考Tarjan's LCA algorithm 《算法导论》第21章习题

http://acm.pku.edu.cn/JudgeOnline/problem?id=2723
较难，2-SAT问题
参考：http://home.ustc.edu.cn/~zhuhcheng/ACM/2-SAT.PPT

http://acm.pku.edu.cn/JudgeOnline/problem?id=2749
较难，2-SAT问题

http://acm.pku.edu.cn/JudgeOnline/problem?id=3164
较难，最小树形图
参考《网络算法与复杂性理论》中朱-刘算法

xunil 2009-11-06 23:31 发表评论

poj 2823 Sliding Window [线段树]

xunil — Fri, 06 Nov 2009 06:36:00 GMT

pku 2823 sliding window 线段树解
题意：一组n个数，一个窗口，大小k，找出窗口中的min和max，然后移动窗口，循环操作。网上有部分说可以用双向单调队列来做，个人分析，觉得如果设计特殊数据的话，可能导致时间复杂度是n^2，而使用线段树的时间复杂度是nlog(n),这题是我做的第一个线段树！所以大概的写下解题报告；

每个节点中主要存的主要信息是当前区间的min和max，其实个人感觉线段树主要的是决定好节点中记录的信息！
如果设计了这样的数据结构基本上就可以解决了！

  1
  2
  3
  4 #include<stdio.h>
  5
  6 int data[1000010] ;
  7
  8 struct tnode
  9 {
10     int left , right ;
11     int min , max ;
12 } t[1000010*4];
13
14 struct out
15 {
16     int min , max ;
17 }  dataout[1000010] ;
18
19 void create( int st , int ed , int r )
20 {
21     t[r].left = st ;
22     t[r].right = ed ;
23
24     if( st == ed )
25     {
26         t[r].min = t[r].max = data[st] ;
27         return ;
28     }
29
30     int mid = (st+ed)>>1 ;
31     create( st , mid , r *2 )  ;
32     create( mid+1 , ed , r*2+1) ;
33
34     // min
35     t[r].min = t[r*2].min ;
36     if( t[r].min > t[r*2+1].min )
37         t[r].min = t[r*2+1].min ;
38
39     // max
40      t[r].max = t[r*2].max ;
41     if( t[r].max < t[r*2+1].max  )
42         t[r].max = t[r*2+1].max ;
43
44 }
45
46 void search( int st ,int ed , int & min , int & max , int r = 1)
47 {
48     if( st == t[r].left && ed == t[r].right )
49     {
50         min = t[r].min ;
51         max = t[r].max ;
52         return ;
53     }
54
55     int mid = ( t[r].left + t[r].right ) >> 1 ;
56
57     if( mid >= ed )
58     {
59         search( st , ed , min , max , r * 2 ) ;
60     }
61     else if( mid < st )
62     {
63         search( st , ed , min , max , r * 2 +1 ) ;
64     }
65     else
66     {
67         int min2 , max2 ;
68         search( st , mid , min , max , r * 2 ) ;
69         search( mid+1 , ed , min2 , max2 , r *2 +1  ) ;
70
71         if( min > min2 )
72             min = min2 ;
73         if( max < max2 )
74             max = max2 ;
75
76     }
77 }
78
79 int main()
80 {
81     //freopen( "in.txt" , "r" , stdin ) ;
82     int n , k ;
83     int i ;
84     scanf( "%d%d" , &n , & k ) ;
85     for( i = 1 ; i<= n ; i++ )
86         scanf( "%d" , & data[i]);
87
88     create( 1 , n , 1 ) ;
89
90     for( i = 1 ; i <= n -k +1 ; i++ )
91     {
92         search( i , i + k -1 , dataout[i].min , dataout[i].max , 1 ) ;
93     }
94     printf( "%d" , dataout[1].min ) ;
95     for( i = 2 ; i<= n- k +1 ; i++  )
96         printf( " %d" , dataout[i].min ) ;
97     printf("\n") ;
98
99     printf("%d" , dataout[1].max ) ;
100     for( i = 2 ; i<= n-k +1 ; i++ )
101         printf(" %d" , dataout[i].max ) ;
102     printf("\n") ;
103     return  0 ;
104 }

xunil 2009-11-06 14:36 发表评论

hoj 1384 Palindrome Number

xunil — Sat, 11 Jul 2009 23:15:00 GMT

   首先做一题之前做了，hoj1004那题，然后就给了自己一个误区，我的一次的想法和写1004时是一样！后来老是出现错误，所以我就改了下思路，算的上是灵光一现吧，因为人很容走入思维的定式，而且走进了就不容易出来！
   废话不说了！这一题说的是寻找2*1e9个范围内的回文数！time：3s，通过推算我们知道最大的那个回文数是19位1000000001000000001，第一次的思路就不说了，呵呵！第二次我是这么想的，从输入的数可以很快的判断是多少位的回文数，那么也能判断是这个位的回文数的第多少个，这个就需要自己算一算了！显然
1： 9
2：9
3：90
4：90
。。。。。
我们能很容易的找到n位回文数中的第ith个回文数！
n位回文数最多有9*e(（n+1/2）-1) 个，我把一个回文数拆成一半，因为是对称的！只要知道一半就够了（如果是奇数位的话，记住是加上中间的那个数），从左半部分看是从10e(（n+1）/2-1)到9..9(共有( n+1)/2 个 9 )，那么你想知道的第ith个回文数是多少呢，就是
10e(（n+1）/2-1) + (ith-1) ,然后输出一下就行了！记得还要反着输出一次啊！

#include<stdio.h>
#include<sstream>
#include<string>
#include<iostream>
using namespace std ;

string itos(int x)
{
    stringstream str ;
    str << x ;
    return str.str() ;
}

int num[20] = { 1 , 1 , 10 , 100 , 1000 , 10000 , 100000 , 1000000 , 10000000 , 100000000 , 1000000000 } ;
void solve( int ith , int  n )
{
    int tem = n ;
    if( n % 2 == 0 )
        tem = n/2 ;
    else
    {
        tem =  n/2 + 1 ;
    }

    int ans = num[tem] + ith - 1 ;

    string str = itos(ans) ;

    int i ;
    if( n % 2 == 0 )
    {
        printf("%d" , ans) ;
    }
    else
    {
        if( ans/10 != 0 )
            printf("%d" , ans /10 ) ;
    }

    for( i = str.length() -1 ; i>= 0 ; i-- )
    {
        cout<<str[i];
    }
    cout<<endl ;
    return ;
}

int jud[] = {    0 ,// 0 位假设 0 这个回文数是 0 位（呵呵）
                9 , 18 , // 1 and 2 位
                108 , 198 , // 3 and 4
                1098 , 1998 , // 5 and 6
                10998 , 19998 , // 7 and 8
                109998 , 199998, // 9 and 10
                1099998 , 1999998 , // 11 and 12
                10999998 , 19999998 , // 13 and 14
                109999998 , 199999998 , // 15 and 16
                1099999998 , 1999999998 } ;// 17 and 18
int main()
{
    //int ntc ;
    //scanf( "%d" , & ntc ) ;
    int n , ith ;
    int i , tem ;
    while( scanf( "%d" , & n ) != EOF)
    {
        if( n == 1999999999 )
        {
            printf("1000000000000000001\n") ;
        }
        else if( n == 2000000000)
        {
            printf("1000000001000000001\n") ;
        }
        else
        {
            for( i = 18 ; i> 0 ; i-- )
            {
                if( n > jud[i-1] && n <= jud[i] )
                {
                    tem = i ;
                    ith = n - jud[i-1] ;
                    break ;
                }
            }
            solve( ith , tem ) ;
        }
    }
    return 0 ;
}

第一次写，不好请见谅，我会努力的！

xunil 2009-07-12 07:15 发表评论