﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>C++博客-Mycode.h-文章分类-ACM</title><link>http://www.cppblog.com/mtysblog/category/15739.html</link><description>just for coding</description><language>zh-cn</language><lastBuildDate>Thu, 27 Jan 2011 17:40:07 GMT</lastBuildDate><pubDate>Thu, 27 Jan 2011 17:40:07 GMT</pubDate><ttl>60</ttl><item><title>[z]位运算与组合搜索（一）</title><link>http://www.cppblog.com/mtysblog/articles/139481.html</link><dc:creator>_飞寒</dc:creator><author>_飞寒</author><pubDate>Thu, 27 Jan 2011 11:41:00 GMT</pubDate><guid>http://www.cppblog.com/mtysblog/articles/139481.html</guid><wfw:comment>http://www.cppblog.com/mtysblog/comments/139481.html</wfw:comment><comments>http://www.cppblog.com/mtysblog/articles/139481.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/mtysblog/comments/commentRss/139481.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/mtysblog/services/trackbacks/139481.html</trackback:ping><description><![CDATA[&nbsp;&nbsp;&nbsp;&nbsp; 摘要: &nbsp;我们知道，一个集合的子集通常可由一个位串来表示，比如对于集合 {a, b, c, d, e}，可用位串 s = &#8221;11001&#8221; 来表示其子集 {a, b, e}。当集合的大小不大于机器的字长（在下文中将假设字长为32）时，这些位串又可用一个无符号整数来表示，比如上面的 s 可以存储为 0b10011 = 19。在此种情形下，很多集合操作都可以通过位运算来...&nbsp;&nbsp;<a href='http://www.cppblog.com/mtysblog/articles/139481.html'>阅读全文</a><img src ="http://www.cppblog.com/mtysblog/aggbug/139481.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/mtysblog/" target="_blank">_飞寒</a> 2011-01-27 19:41 <a href="http://www.cppblog.com/mtysblog/articles/139481.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>USACO-- 搜索方式</title><link>http://www.cppblog.com/mtysblog/articles/137046.html</link><dc:creator>_飞寒</dc:creator><author>_飞寒</author><pubDate>Mon, 20 Dec 2010 13:36:00 GMT</pubDate><guid>http://www.cppblog.com/mtysblog/articles/137046.html</guid><wfw:comment>http://www.cppblog.com/mtysblog/comments/137046.html</wfw:comment><comments>http://www.cppblog.com/mtysblog/articles/137046.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/mtysblog/comments/commentRss/137046.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/mtysblog/services/trackbacks/137046.html</trackback:ping><description><![CDATA[<div align=left>&nbsp;</div>
<div align=left>
<table width=892 align=left>
    <tbody>
        <tr>
            <td width=17>&nbsp;&nbsp;</td>
            <td width=861><br><strong><font size=4>Search Techniques</font></strong>
            <p align=left><strong><font size=4>搜索方式</font></strong></p>
            <p align=center><font size=2><strong>译 by Lucky Craz</strong></font></p>
            <h4>样例: <em>n</em> 皇后问题 [经典问题]</h4>
            <p>将 <em>n</em> 个皇后摆放在一个 <em>n x n</em> 的棋盘上，使得每一个皇后都无法攻击到其他皇后。</p>
            <p><strong>深度优先搜索 (DFS)</strong></p>
            <p>显而易见，最直接的方法就是把皇后一个一个地摆放在棋盘上的合法位置上，枚举所有可能寻找可行解。可以发现在棋盘上的每一行（或列）都存在且仅存在一个皇后，所以，在递归的每一步中，只需要在当前行(或列）中寻找合法格，选择其中一个格摆放一个皇后。<br><tt><font size=2><br>&nbsp;1&nbsp;search(col)<br>&nbsp;2&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;filled&nbsp;all&nbsp;columns<br>&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print&nbsp;solution&nbsp;and&nbsp;exit&nbsp;<br><br>&nbsp;4&nbsp;&nbsp;&nbsp;for&nbsp;each&nbsp;row<br>&nbsp;5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;board(row,&nbsp;col)&nbsp;is&nbsp;not&nbsp;attacked<br>&nbsp;6&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;place&nbsp;queen&nbsp;at&nbsp;(row,&nbsp;col)<br>&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;search(col+1)<br>&nbsp;8&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;remove&nbsp;queen&nbsp;at&nbsp;(row,&nbsp;col)<br></font></tt></p>
            <p>从search(0)开始搜索，由于在每一步中可选择的节点较少，该方法可以较快地求解：当一定数量的皇后被摆放在棋盘上后那些不会被攻击到的节点的数量将迅速减少。</p>
            <p>这是<strong>深度优先搜索</strong>的一个经典例题，该算法总是能尽可能快地抵达搜索树的底层：当 <em>k</em> 个皇后被摆放到棋盘上时，可以马上确定如何在棋盘上摆放下一个皇后，而不需要去考虑其他的顺序摆放皇后可能造成的影响（如当前情况是否为最优情况），该方法有时可以在找到可行解之前避免复杂的计算，这是十分值得的。</p>
            <p>深度优先搜索具有一些特性，考虑下图的搜索树：</p>
            <p><br><img src="http://www.oiers.cn/usaco%20training/tree1.gif"></p>
            <p><br>该算法用逐步加层的方法搜索并且适当时回溯，在每一个已被访问过的节点上标号，以便下次回溯时不会再次被搜索。绘画般地，搜索树将以如下顺序被遍历：</p>
            <p><br><img src="http://www.oiers.cn/usaco%20training/rec2.gif"><br></p>
            <h5><font size=3>复杂度：</font></h5>
            <p>假设搜索树有 <em>d</em> 层（在样例中 <em>d=n ，</em>即棋盘的列数）。再假设每一个节点都有 <em>c</em> 个子节点（在样例中，同样 <em>c=n</em> ，即棋盘的行数，但最后一层没有子节点，除外）。那么整个搜索花去的时间将与 <em>c<sup>d</sup></em> 成正比，是指数级的。但是其需要的空间较小，除了搜索树以外，仅需要用一个栈存储当前路径所经过的节点，其空间复杂度为 O(<em>d</em>) 。</p>
            <h4>样例：骑士覆盖问题[经典问题]</h4>
            <p>在一个 <em>n x n</em> 的棋盘中摆放尽量少的骑士，使得棋盘的每一格都会被至少一个骑士攻击到。但骑士无法攻击到它自己站的位置.</p>
            <h5><font size=3>广度优先搜索 (BFS)</font></h5>
            <p>在这里，最好的方法莫过于先确定 <em>k</em> 个骑士能否实现后再尝试 <em>k+1</em> 个骑士，这就叫<strong>广度优先搜索</strong>。通常，广度优先搜索需用队列来帮助实现。<br><tt><font size=2><br>&nbsp;1&nbsp;process(state)<br>&nbsp;2&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;each&nbsp;possible&nbsp;next&nbsp;state&nbsp;from&nbsp;this&nbsp;one<br>&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;enqueue&nbsp;next&nbsp;state&nbsp;<br><br>&nbsp;4&nbsp;search()<br>&nbsp;5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;enqueue&nbsp;initial&nbsp;state<br>&nbsp;6&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;while&nbsp;!empty(queue)<br>&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;state&nbsp;=&nbsp;get&nbsp;state&nbsp;from&nbsp;queue<br>&nbsp;8&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;process(state)<br></font></tt></p>
            <p>广度优先搜索得名于它的实现方式：每次都先将搜索树某一层的所有节点全部访问完毕后再访问下一层, 再利用先前的那颗搜索树，广度优先搜索以如下顺序遍历：</p>
            <p><br><img src="http://www.oiers.cn/usaco%20training/rec3.gif"></p>
            <p><br>首先访问根节点，而后是搜索树第一层的所有节点，之后第二层、第三层厖以此类推。</p>
            <h5><font size=3>复杂度：</font></h5>
            <p>广度优先搜索所需的空间与深度优先搜索所需的不同（ <em>n</em> 皇后问题的空间复杂度为 O(<em>n</em>) ）,广度优先搜索的空间复杂取决于每层的节点数。如果搜索树有 <em>k</em> 层，每个节点有 <em>c</em> 个子节点，那么最后将可能有 <em>c <sup>k</sup></em> 个数据被存入队列，这个复杂度无疑是巨大的。所以在使用广度优先搜索时，应小心处理空间问题。</p>
            <h5><font size=3>迭代加深搜索 (ID)</font></h5>
            <p>广度优先搜索可以用迭代加深搜索代替。迭代加深搜索实质是限定下界的深度优先搜索，即首先允许深度优先搜索搜索 <em>k</em> 层搜索树，若没有发现可行解，再将 <em>k+1</em> 后再进行一次以上步骤，直到搜索到可行解。这个?#27169;仿广度优先搜索?#25628;索法比起广搜是牺牲了时间，但节约了空间。<br><tt><font size=2><br>&nbsp;1&nbsp;truncated_dfsearch(hnextpos,&nbsp;depth)<br>&nbsp;2&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;board&nbsp;is&nbsp;covered<br>&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print&nbsp;solution&nbsp;and&nbsp;exit&nbsp;<br><br>&nbsp;4&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;depth&nbsp;==&nbsp;0<br>&nbsp;5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;<br><br>&nbsp;6&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;i&nbsp;from&nbsp;nextpos&nbsp;to&nbsp;n*n<br>&nbsp;7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;put&nbsp;knight&nbsp;at&nbsp;i<br>&nbsp;8&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;truncated_dfsearch(i+1,&nbsp;depth-1)<br>&nbsp;9&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;remove&nbsp;knight&nbsp;at&nbsp;i&nbsp;<br><br>10&nbsp;dfid_search<br>11&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;depth&nbsp;=&nbsp;0&nbsp;to&nbsp;max_depth<br>12&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;truncated_dfsearch(0,&nbsp;depth)<br></font></tt></p>
            <h5><strong><font size=3>复杂度：</font></strong></h5>
            <p>　</p>
            <p>ID时间复杂度与DFS的时间复杂度（<em>O(n)</em>）不同，另一方面，它要更复杂，某次DFS若限界 <em>k</em> 层<em>，</em>则耗时 <em>c</em><sup><em>k</em></sup> <em>。</em>若搜索树共有 <em>d</em> 层，则一个完整的DFS-ID将耗时 <em>c<sup>0</sup> + c<sup>1</sup> + c<sup>2</sup> + ... + c<sup>d</sup></em> 。如果 c = 2 ，那么式子的和是 <em>c<sup>d+1</sup> - 1</em> ，大约是同效BFS的两倍。当 c &gt; 2 时（子节点的数目大于2），差距将变小：ID的时间消耗不可能大于同效BFS的两倍。所以，但数据较大时，ID-DFS并不比BFS慢，但是空间复杂度却与DFS相同，比BFS小得多。</p>
            <h4>算法选择：</h4>
            <p>当你已经知道某题是一道搜索题，那么选择正确的搜索方式是十分重要的。下面给你一些选择的依据。</p>
            <h5><font size=3>简表：</font></h5>
            <table height=141 width=827>
                <tbody>
                    <tr>
                        <td width=74 height=30>搜索方式</td>
                        <td width=63 height=30>时间</td>
                        <td width=63 height=30>空间</td>
                        <td width=601 height=30>使用情况</td>
                    </tr>
                    <tr>
                        <td width=74 height=25>DFS</td>
                        <td width=63 height=25>O(<em>c <sup>k</sup></em>)</td>
                        <td width=63 height=25>O(<em>k</em>)</td>
                        <td width=601 height=25>必须遍历整棵树，要求出解的深度或经的过节点，或者你并不需要解的深度最小。</td>
                    </tr>
                    <tr>
                        <td width=74 height=35>BFS</td>
                        <td width=63 height=35>O(<em>c <sup>d</sup></em> )</td>
                        <td width=63 height=35>O(<em>c <sup>d</sup></em> )</td>
                        <td width=601 height=35>了解到解十分靠近根节点，或者你需要解的深度最小。</td>
                    </tr>
                    <tr>
                        <td width=74 height=35>DFS+ID</td>
                        <td width=63 height=35>O(<em>c <sup>d</sup></em>)</td>
                        <td width=63 height=35>O(<em>d</em>)</td>
                        <td width=601 height=35>需要做BFS，但没有足够的空间，时间却很充裕。</td>
                    </tr>
                </tbody>
            </table>
            <em>d</em> ：解的深度<br><em>k</em> ：搜索树的深度<br><em>d &lt;= k</em>
            <p>记住每一种搜索法的优势。如果要求求出最接近根节点的解，则使用BFD或ID。而如果是其他的情况，DFS是一种很好的搜索方式。如果没有足够的时间搜出所有解。那么使用的方法应最容易搜出可行解，如果答案可能离根节点较近，那么就应该用BFS或ID，相反，如果答案离根节点较远，那么使用DFS较好。还有，请仔细小心空间的限制。如果空间不足以让你使用BFS，那么请使用迭代加深吧！</p>
            <h4>类似问题：</h4>
            <h5><font size=3>超级质数肋骨[USACO 1994 决赛]</font></h5>
            <p>一个数，如果它从右到左的一位、两位直到N位（N是）所构成的数都是质数，那么它就称为超级质数。例如：233、23、2都是质数，所以233是超级质数。要求：读入一个数N（N &lt;=&nbsp; 9），编程输出所有有N位的超级质数。</p>
            <p>这题应使用DFS，因为每一个答案都有N层（最底层），所以DFS是最好的．</p>
            <h5><font size=3>Betsy的旅行 [USACO 1995 资格赛]</font></h5>
            <p>一个正方形的小镇被分成 <em>NxN</em> (2 &lt;= <em>N</em> &lt;= 6）个小方格，Besty 要从左上角的方格到达左下角的方格，并且经过每一次方格都恰好经过一次。编程对于给定的 <em>N</em> 计算出 Besty 能采用的所有的旅行路线的数目。</p>
            <p>这题要求求出解的数量，所以整颗搜索树都必须被遍历，这就与可行解的位置与出解速度没有关系了。所以这题可以使用BFS或DFS，又因为DFS需要的空间较少，所以DFS是较好的．</p>
            <h5><font size=3>奶牛运输 [USACO 1995 决赛]</font></h5>
            <p>奶牛运输公司拥有一辆运输卡车与牧场 A ，运输公司的任务是在A，B，C，D，E，F和G七个农场之间运输奶牛。每两个农场之间的路程（可以用floyed改变）已给出。每天早晨，运输公司都必须确定一条运输路线，使得运输的总距离最短。但必须遵守以下规则：</p>
            <ul>
                <li>农场 A 是公司的基地。每天的运输都必须从这开始并且在这结束。
                <li>卡车任何时刻都只能最多承载一头奶牛。
                <li>给出的数据是奶牛的原先位置与运输结束后奶牛所在的位置。 </li>
            </ul>
            <p>而你的任务是在上述规则内寻找最短的运输路线。</p>
            <p>在发现最优解时必须比较所有可行解，所以必须遍历整棵搜索树。所以，可以用DFS解题．</p>
            <h5><font size=3>横越沙漠 [1992 IOI]</font></h5>
            <p>一群沙漠探险者正尝试着让他们中的一部分人横渡沙漠。每一个探险者可以携带一定数量的水，同时他们每天也要喝掉一定量的水。已知每个探险者可携带的水量与每天需要的水量都不同。给出每个探险者能携带的水量与需要的水量与横渡沙漠所需的天数，请编程求出最多能有几个人能横渡沙漠。所有探险者都必须存活，所以有些探险者在中途必须返回，返回时也必须携带足够的水。当然，如果一个探险者返回时有剩余的水（除去返回所需的水以外），他可以把剩余的水送给他的一个同伴，如果它的同伴可以携带的话。</p>
            <p>这题可以分成两个小问题，一个是如何为探险者分组，另一个是某些探险者应在何处返回。所以使用ID-DFS是可行的。首先尝试每一个探险者能否独自横渡，然后是两个人配合，三个人配合。直到结束。</p>
            </td>
        </tr>
    </tbody>
</table>
</div>
<div align=left></div>
<img src ="http://www.cppblog.com/mtysblog/aggbug/137046.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/mtysblog/" target="_blank">_飞寒</a> 2010-12-20 21:36 <a href="http://www.cppblog.com/mtysblog/articles/137046.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>GDCPC 2010 总结</title><link>http://www.cppblog.com/mtysblog/articles/137044.html</link><dc:creator>_飞寒</dc:creator><author>_飞寒</author><pubDate>Mon, 20 Dec 2010 13:33:00 GMT</pubDate><guid>http://www.cppblog.com/mtysblog/articles/137044.html</guid><wfw:comment>http://www.cppblog.com/mtysblog/comments/137044.html</wfw:comment><comments>http://www.cppblog.com/mtysblog/articles/137044.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/mtysblog/comments/commentRss/137044.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/mtysblog/services/trackbacks/137044.html</trackback:ping><description><![CDATA[<div>&nbsp;</div>
<div>&nbsp;&nbsp;&nbsp; 一转眼就六月中了，九号那天我问了一个女孩子，记得今天是啥日子么，本来我是想告诉她今天是6.9圣战 （狂汗 ⊙﹏⊙b），可是她不假思索的跟我说今天是我们两相识正好一个月的日子&#8230;&#8230; 我那个惭愧啊！我是想说不知道我这人活得是不是太不负责任了，连日子流逝的速度都不曾注意，省赛到现在一个月多了，我一篇日志和总结都没写，正课的进度又落下了许多，算法却没有多学到多少。不过还好我和以前不同了，凡事都知道有意识的去控制，不让自己不知不觉中放纵下去，所以上来例行更新一下。</div>
<div>&nbsp;&nbsp;&nbsp; 先说重点，那就是省赛的总结。教练最后通牒不写总结的明年就不用比赛了（⊙﹏⊙b）结果我们队三儿到现在还是没写&#8230;&#8230; 言归正传，这里就只总结正赛上的情况，至于路上路下中大观光最后还如此美好的邂逅了一个好女孩这些就不总结了。五月九正赛是这样的，十一道题，十道常规梯度的题目外加一道郭嵩山&#8220;保证每个队都通过一道题&#8221;&#8230;&#8230; 的一道题（汗）。上场之后大家开始读题，哥我英文烂素来天知地知我知现在也顺便让你知了，于是常规的先看风景，队友读题。三十秒后LXJ惊呼A题是水题，于是我赶紧上位，我又是连题面都没看的情况下光听LXJ讲完就按她说的敲&#8230;&#8230; 她讲完的时候我正好敲完，XJ问我她想得到底对不对，我说我不知道啊我很相信你的。他们都很紧张唯独我不紧张（果然我最没团队责任感 stO）&#8230;&#8230; 交了，1Y。开始分头读题，我因为中间看到一道中国剩余定理变种的题，大感兴奋地投入其中。不知过了多久XJ把我拽了回来讲B的题意，讲完第一遍，我什么都没听懂&#8230;&#8230; 重复了三四遍再加上我自己的分析后才大概明白了，和他们商量了下，画了下草稿纸找不到通项公式之类的东西，最后他们两看着1后面跟着的5个0天真的说我们模拟一下八！^_^ &#8230;&#8230; 事实证明我让他们想别的是正确的，要不然GDCPC2010就不用过别的题了&#8230;&#8230; 话分两头，在我纠结的时候，SWH和LXJ也在艰难的读别的题，因为三个09的阵容实力实在有限，大部分题读出来了也不会做，最后没办法只好开始跟风策略。这时候我看了下全局，我们房间的人基本把AB都过掉了stO，还有很多人过了最后一个题，至于我们房间里的那个final队那就可以忽略了&#8230;&#8230;</div>
<div>&nbsp;&nbsp;&nbsp; 由于大部分题不懂，他们开始跟风看K，很快发现是一个表面上看很熟悉的搜索题。再说我这边，历经一个多小时的纠结之后我终于确定了B程序的边界条件，二话不说果断交之，仍然1Y。说说这B题的教训，其实我的代码核心不过八行，应该说思路很精湛了，结果却因为对确定边界条件这种事不熟练，最后浪费了那么多时间，应该说根本原因还是练得不够吧，继续努力。他们这边在我Y掉之后说明了下K的题意，开始合力纠结一道蓝色气球的基本题。我孤独的纠结K。对于那道蓝色气球，因为我没有参与细节，所以没什么发言权，他们一共wa了4次+TLE1次+RE一次(汗)，可能是理解上的疏忽，也可能这道题真的有难度吧。我知道我该改变了，以后不能把事情都放给他们，或许我当时帮忙看一下的话，也不至于罚那么多次。</div>
<div>&nbsp;&nbsp;&nbsp; 因为一共也就过掉了三个题，剩下的也没多少好说的了，重点就是我的K是如何在纠结的。这是一道完全图的搜索，暴力DFS的话肯定会O(n!)无疑，其实我也坚信是动态规划写法，但可悲的是在最后长达两个小时的时间里，我始终没能把完整的状态转移方程纠结出来，我的方程始终存在后效性。后来我居然开始怀疑自己的想法到底对不对了，在最后一小时的时候，没办法必须下手尝试了。这是一个纯ＤＦＳ的版本不加任何剪枝（其实这道题也剪不了什么），很不幸良心告诉我这是不可能的&#8230;&#8230;　敲到最后，我在队友的注视下放弃了。我对不起你们。我最后还是没能想出来，这与我赛前信誓旦旦的说一定要把动规的题目拿下的誓言形成鲜明讽刺。</div>
<div>　</div>
<div>总结：　</div>
<div>　　　这次比赛，有了校内赛和珠海赛的经验，我们的配合已经算是顺风顺水的了，唯一限制我们的就是积累。很遗憾Ｋ题就是动态规划，只是我还是没能啃出来，这就是实力问题，我明白的。总而言之，一切都有待提高，我的修炼从未止步，我相信你们也是，ＧＤＣＰＣ２０１１见。</div>
<img src ="http://www.cppblog.com/mtysblog/aggbug/137044.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/mtysblog/" target="_blank">_飞寒</a> 2010-12-20 21:33 <a href="http://www.cppblog.com/mtysblog/articles/137044.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>2010校内赛总结</title><link>http://www.cppblog.com/mtysblog/articles/137043.html</link><dc:creator>_飞寒</dc:creator><author>_飞寒</author><pubDate>Mon, 20 Dec 2010 13:32:00 GMT</pubDate><guid>http://www.cppblog.com/mtysblog/articles/137043.html</guid><wfw:comment>http://www.cppblog.com/mtysblog/comments/137043.html</wfw:comment><comments>http://www.cppblog.com/mtysblog/articles/137043.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/mtysblog/comments/commentRss/137043.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/mtysblog/services/trackbacks/137043.html</trackback:ping><description><![CDATA[<p><font style="BACKGROUND-COLOR: #a0a0a4"></font>&nbsp;</p>
<p>&nbsp;</p>
<p>关键词： ACM 北师大 2010 校内赛&nbsp; 总结 0.o_stO_(*^_^*)<br>&nbsp;</p>
<p>一点半正式比赛开始，拿到题目后，我们原本打算按珠海赛的计划分工读题，无奈看见水题实在是顺着排的，导致我们不得不集体看前面的题目。当时自己拿到题扫了一眼目录，看到&#8220;二叉树&#8221;三个大字，以为CC老师出裸题，于是立马开始读题，让刘晓佳和石文辉研究其他送气球的题目。<br>这时候辉哥读完A题让我第一个敲，说是可以壮士气，于是我在完全没看过题目的情况下听辉哥讲完就敲了，hash查找Ａ之。<br>之后继续攻Ｅ，题没读完晓佳和辉哥就说已经确定了Ｂ的写法，于是再次不用读题，听辉哥讲完就敲了。取出qsort模板，瞬间A之。<br>提交B之后继续攻E，题目读完发现不是裸题更明显不是考二叉树，而我一看到是数学题，又本能的想先放一放，于是改读F题。这时候晓佳明了C题，于是换人敲代码，似乎敲得挺慢条斯理的，导致我们另外两个人也悠哉游哉。这时候我已经决定攻F，辉哥研究D题。经过一段时间之后晓佳说C过掉了，我抬头看表，切前三题用一小时，时间充裕。<br>F题读完之后，粗略规划了下算法：构建N叉树，因为对树的最小染色数就是二，解法便很明显了，对树做层序遍历，分别求出偶数树深和奇数树深的节点数，枚举与价格的乘积即可。算法确定之后，又考虑到此题不是给09的做的，保险起见还是等队友把基本题目都过掉再写好了，于是转身问辉哥D题的进度，辉哥说有想法但是比较麻烦。我觉得模拟题虽然麻烦但应该一两个人就能应付了，于是叫晓佳和辉哥一起考虑D题，而我则另外去考虑E，结果这个决定铸成本次比赛第一大错，以后有教训了。<br>看完E题，用稿纸模拟了几个深度，仍然找不出规律。我也不确定是存在递推式还是有直接的f(a,b)。这时候我看了下两人的情况，他们已经开始敲D题的代码，但是敲得很慢。于是我问他们这题有完全的把握没有，他们说还好，试一下。听完这句话我就大概猜到麻烦了，因为两人是很少这么说的。但因为我也没读过题，所以觉得也许真的是很麻烦的模拟题，想到辉哥平时模拟题的正确率的确比我高，于是交待他们一定要想清楚了再写，然后就考虑我的了，这时候一个半小时过去了，两边都不太有头绪。<br>大概再过了十几分钟，我看看表，问辉哥什么情况，辉哥说写完了但是样例调不过，于是我让晓佳过来和我一起考虑E题，中途试敲了一次O(n)的逆推，预料之中的TLE。<br>再过了十几分钟，E题毫无头绪，于是我不得不起来看看其他队伍的情况了：大量09的队伍通过了D题！不得了，一个小时过去了而我们的队伍一题的进度都没有！看看辉哥，辉哥似乎还是没找出错误，于是我决定有必要开新题了。因为E题实在没有头绪，所以我决定留给数学功底好点的晓佳继续想，自己开始在草稿纸上设计F的代码。结果边写边发现这代码实现起来远没有我想象的复杂，十几分钟就写完了很短的完整品。这时候我要辉哥开半个屏幕继续查，而我就把F的代码敲上去，敲完之后测试也一路顺风顺水，于是在两人的怂恿下，拜了拜曾哥就交了。三十秒之后打开界面，一个绿油油的YES!!! <br>这个YES可谓我们队伍的转折点。<br>不能不说，F题的AC让我们队伍信心大增。我这时候终于可以回来和两人一起攻D了，这时候比赛已经过去了三个小时，中间有一个小时的时间是一点进度都没有，而有将近半个小时的时间（也就是我手写F题的时间）我们队伍的键盘是闲置状态！对于出现了这种情况，我知道是自己安排分工失误造成的，我应该承担责任。<br>静下心来细读完D题，一看这个结构，第一反应是用数组队列或者指针链表做，再稍微细想了下代码的实现，发现确实不算复杂。而最重要的是两人如今的程序已经被调到不堪入目的样子了，于是我提议让我重写D题，这时候还有45分钟。<br>十五分钟后写完单链表的做法，开始调试。第二组数据卡之，从头想了一遍思路，确认没有错误，于是开始排BUG。最后发现数字与串之间的空格没有冲掉。改完再测，这时候诡异的情况开始上演，单组测试数据输入的时候无误，但连续输入的时候就会出错！症状诡异到无法从字面上看出错误来，于是不得不下断点去跟踪，费尽一连串无法形容的周折之后，辉哥发现是我把表头free()掉了两次。改之，希望降临。<br>这时候看看表，17：17分，还有十三分钟，晓婷能不能看到我们拍方大同回来，基本就看这一次提交了。于是在晓佳和辉哥的注视下，我确实是手有点颤抖地点下了submit&#8230;&#8230;<br>在那十几秒的时间里我们三个人把曾哥春哥佛哥都拜了个遍。<br>最后的最后，那个&#8220;D Judge YES&#8221;，带给了我们三个人第二声发自肺腑的尖叫。<br>&nbsp;<br>--------------------------------------------------------------------<br>这次比赛下来，有好有坏，好的方面就是，我们队伍的正确率是百分百。联想到自己做英文题目时的悲惨情况，就能得出一个清晰的结论：\<br>&nbsp;耐心*[明了题意+（清晰+完整）*的思路]=AC。<br>当然这次比赛下来也暴露了很多的问题，首先是我们的人员分工中途发生了不合理的现象，导致键盘被完全闲置了半个多小时，我太过于执着自己的两道题目，而没有顾及队友，使得两道题目在最后一个小时才先后被过掉，在时间上已经输掉了不少。如果当时自己先放下E题去帮忙看D，我们队伍的总耗时绝对不会是现在这样结果，而且还能有更多的时间去考虑别的题目（其实在最后几分钟，晓佳在看完H题之后，很认真的告诉我，她在当年高中的数学试卷上做过类似的问题&#8230;&#8230;&nbsp; Orz ）！！！<br>&nbsp; 然后是关于出错调试的问题，这次队伍在D题上的调试值得商榷，花掉了太多的时间并且始终没有调出原因来，这一点我们全体队员都有责任，今后再遇到类似的问题时，必须得懂得果断重写了。<br>&nbsp;其次，自己在数学题上的发挥也十分不好，一开始就产生了本能的逃避心理，实在是不应该。我也知道数学题是可以拉开排名的题目，以后自己一定要下更多功夫在这上面了。<br>最后自己得出的一点教训就是，即使是ACM的比赛，个人英雄主义也是无益的，队员的最终目的应该是要让队伍的整体成绩更好，而不应该纯粹为了让自己发挥得更出色。<br>以上各点，自己今后一定谨记。</p>
<img src ="http://www.cppblog.com/mtysblog/aggbug/137043.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/mtysblog/" target="_blank">_飞寒</a> 2010-12-20 21:32 <a href="http://www.cppblog.com/mtysblog/articles/137043.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>int_ijk 2009ACM珠海赛总结</title><link>http://www.cppblog.com/mtysblog/articles/137042.html</link><dc:creator>_飞寒</dc:creator><author>_飞寒</author><pubDate>Mon, 20 Dec 2010 13:30:00 GMT</pubDate><guid>http://www.cppblog.com/mtysblog/articles/137042.html</guid><wfw:comment>http://www.cppblog.com/mtysblog/comments/137042.html</wfw:comment><comments>http://www.cppblog.com/mtysblog/articles/137042.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/mtysblog/comments/commentRss/137042.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/mtysblog/services/trackbacks/137042.html</trackback:ping><description><![CDATA[<p>&nbsp;</p>
<p>关键字: ACM ICPC 珠海赛 金山杯 2009 BNUEP int_ijk</p>
<p>注：这是高手的心得，高手就是高手。。。 学弟怎么能不MB+YM，收藏之</p>
<p>===================================================================================================</p>
<p>这是有史以来最神奇的一次比赛.</p>
<p>这种神奇的迹象从一大早就开始持续...去科干院要坐车一个半小时, 和去一趟广州差不多的时间. 10点钟开始比赛, 我们学校8支队伍7点半悠闲地坐着大巴过去了. 按照北理工的教练的说法就是, 你们学校也太不重视比赛了, 怎么都不住那边. 不过也的确, 要是这次来得及的话, 那么省赛的时候一大早出发应该也来得及&gt;_&lt;</p>
<p>然后一个神奇的地方是, 比赛一共分了6个机房. 而且机器良莠不齐, 差距及其巨大. (据说把机房分成了三个等级,上等房,中等房和下等房, 每个学校按比例分配...)然后我们队自从用了int_ijk队名之后, 每次比赛都是在角落里. 这次也不例外, 被分配到了最后排的左下角, 纵观全场.</p>
<p>--------按照惯例 下面是流水账----------------</p>
<p>先列举一下题目</p>
<p>Apple Tree: 线性DP. Banana Game: 博弈. Cross Words: 字符串查找.</p>
<p>Download Again: 简单题. Encrypted SMS: 中序遍历. Football Match: 概率.</p>
<p>General Problem: 三次方程求根. Horse in Chinese Chess: 广搜.</p>
<p>Insect World: 模拟. Jack's Lost Lists: 枚举.</p>
<p>开始分头看题, 尚鹏ABC, 我DEF,许翰中GHIJ. 大约20分钟的时候交流了一下, 尚鹏说B是博弈, 之前做过的原题. 我看了DE, 觉得都是简单题, 不过还感觉应该不是最简单的题目,所以没有马上上去写(后来发现整套题目都是这种难度,没有很大的区分度). 过了一会儿我先去写D, 许翰中说不用模拟, 直接用文件总大小除以带宽就好了. 于是很快写完, 一次AC了.</p>
<p>尚鹏说B做过, 然后很神奇的拿出一篇论文, 上面有一个终极公式. 敲上去瞬间过掉了. 我倒比较担心的是怕我们学校的其他几个队伍跟风的话肯能被卡住.</p>
<p>然后是许翰中上去写了A题, 尚鹏帮忙看了一下DP公式. 好像怎么错了一次, 然后就AC掉了.</p>
<p>这个时候大概是1小时多一点. 我换上去写C题. 这个题题意挺奇怪, 我们交流了好几次才确认了题意. 看了一下数据量不大, 也有好几个队过了, 应该不用字典树, 二分查找就行. 敲完代码也一次AC了.</p>
<p>E题其实按照题目所说的方式递归进去, 前序输出就好了. 许翰中上去敲, 我帮忙看代码, 貌似也是一次AC的.</p>
<p>这个时候尚鹏弄完F题, 用最直接求概率的方法就好了, 打了个表, 也一次AC的.</p>
<p>看了一下排名, 发现I题挺多人过, 于是我看了一下, 发现直接模拟就可以. 找最近点线性扫描也不会超时. 于是也很快AC了.</p>
<p>现在还剩三个题, G,H,J. 大约还有两个半小时吧. 时间很充裕. 但是华农那个队已经9题了...我们排在第二, 已经觉得赶不上了, 于是心理上已经做好了最后排在第二的准备...</p>
<p>许翰中看完J题就惊呼--原题!于是拿出黑书,我一看果然..&gt;_&lt; 这个时侯尚鹏上去敲G题, 我在旁边帮忙看J题, 也准备着些H题. 敲完发现有点问题, 于是打印下来. 换许翰中上去写J, 用黑书上的n^3的算法. 提交了, 发现不对... 于是换我上去些H. 但是我又有点担心说这个时候开三个题是不是有点冒险, 然后他俩说没事, 大不了回去写检讨. 我说好, 于是就去敲H. 敲完发现也不对..于是又换尚鹏继续改G. 好像是代码里面某个地方敲错了, 改好了提交AC了.</p>
<p>现在剩两个题, 代码都差不多写好了, 还有一个半小时不到吧. 我和许翰中轮流纠结H和J. 许翰中错了好几次, 后来觉得是不是可能枚举出来的解会不合法, 于是加强了对解得限制, 然后AC了.</p>
<p>还有一小时, 还剩我这个题, 应该很快就能AC. 第一次提交犯了低级错误, 调试的时候把枚举的步数改小了, 提交忘了该回来. 结果得到一个TLE. 这个TLE吓了我一跳, 反复算了复杂度不可能超时啊. 估计是裁判判错了, 害我好几分钟都没敢提交. 改了两个地方之后提交还是WA. 检查了好久才发现, 判断重复的时候,我是判断记录步数的数组值是否为0, 这里导致了BUG, 因为计算的时候有模2008, 求了模之后原来不为0的也可能为0了... 汗.改了这里提交AC了.</p>
<p>这个时候, 还有大约半小时比赛结束, 教练在遥远的某个地方收到一条裁判发来的短信"你们圆满了"...汗.</p>
<p>-----------------------------------------------</p>
<p>第一次比赛的时候做完所有的题目, 感觉题目没有拉出梯度来. 简单的不够简单, 难题也不够难. 而且我们惊呼了好几次--原题...(不过也情有可原, 出题者的时间实在太仓促).到最后的时候时候看排名发现华农那队依然9题..我们等比赛结束的那段时间就一直在算罚时...</p>
<p>最后结果是, 我们学校1个一等奖, 2个二等奖, 3个三等奖. 还有两个08级的队伍缺乏经验可惜没能拿奖.</p>
<p>总的来说这次比赛运气的成分占了很大因数, 遇到好几个原题, 而且这么多次比赛第一次用上了带来的资料. 这次我们队正确率还算可以, 不用写检讨, 不过我最后一个题还是犯了一个低级错误和一个高级错误, 有点过意不去...</p>
<img src ="http://www.cppblog.com/mtysblog/aggbug/137042.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/mtysblog/" target="_blank">_飞寒</a> 2010-12-20 21:30 <a href="http://www.cppblog.com/mtysblog/articles/137042.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>ACM主要算法介绍</title><link>http://www.cppblog.com/mtysblog/articles/137039.html</link><dc:creator>_飞寒</dc:creator><author>_飞寒</author><pubDate>Mon, 20 Dec 2010 13:20:00 GMT</pubDate><guid>http://www.cppblog.com/mtysblog/articles/137039.html</guid><wfw:comment>http://www.cppblog.com/mtysblog/comments/137039.html</wfw:comment><comments>http://www.cppblog.com/mtysblog/articles/137039.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/mtysblog/comments/commentRss/137039.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/mtysblog/services/trackbacks/137039.html</trackback:ping><description><![CDATA[<div>1.图论<br>2.数据结构<br>3.搜索<br>4.动态规划<br>5.模拟<br>6.数学<br>7.计算几何<br>8.博弈论<br>9.字符串<br>＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝<br>初期:<br>一.基本算法:<br>(1)枚举. (poj1753,poj2965)<br>(2)贪心(poj1328,poj2109,poj2586)<br>(3)递归和分治法.<br>(4)递推.<br>(5)构造法.(poj3295)<br>(6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996)<br>二.图算法:<br>(1)图的深度优先遍历和广度优先遍历.<br>(2)最短路径算法(dijkstra,bellman-ford,floyd,heap+dijkstra)<br>(poj1860,poj3259,poj1062,poj2253,poj1125,poj2240)<br>(3)最小生成树算法(prim,kruskal)<br>(poj1789,poj2485,poj1258,poj3026)<br>(4)拓扑排序 (poj1094)<br>(5)二分图的最大匹配 (匈牙利算法) (poj3041,poj3020)<br>(6)最大流的增广路算法(KM算法). (poj1459,poj3436)<br>三.数据结构.<br>(1)串 (poj1035,poj3080,poj1936)<br>(2)排序(快排、归并排(与逆序数有关)、堆排) (poj2388,poj2299)<br>(3)简单并查集的应用.<br>(4)哈希表和二分查找等高效查找法(数的Hash,串的Hash)<br>(poj3349,poj3274,POJ2151,poj1840,poj2002,poj2503)<br>(5)哈夫曼树(poj3253)<br>(6)堆<br>(7)trie树(静态建树、动态建树) (poj2513)<br>四.简单搜索<br>(1)深度优先搜索 (poj2488,poj3083,poj3009,poj1321,poj2251)<br>(2)广度优先搜索(poj3278,poj1426,poj3126,poj3087.poj3414)<br>(3)简单搜索技巧和剪枝(poj2531,poj1416,poj2676,1129)<br>五.动态规划<br>(1)背包问题. (poj1837,poj1276)<br>(2)型如下表的简单DP(可参考lrj的书 page149):<br>1.E[j]=opt{D+w(i,j)} (poj3267,poj1836,poj1260,poj2533)<br>2.E[i,j]=opt{D[i-1,j]+xi,D[i,j-1]+yj,D[i-1][j-1]+zij} (最长公共子序列)</div>
<div>(poj3176,poj1080,poj1159)<br>3.C[i,j]=w[i,j]+opt{C[i,k-1]+C[k,j]}.(最优二分检索树问题)<br>六.数学<br>(1)组合数学:<br>1.加法原理和乘法原理.<br>2.排列组合.<br>3.递推关系.<br>(POJ3252,poj1850,poj1019,poj1942)<br>(2)数论.<br>1.素数与整除问题<br>2.进制位.<br>3.同余模运算.<br>(poj2635, poj3292,poj1845,poj2115)<br>(3)计算方法.<br>1.二分法求解单调函数相关知识.(poj3273,poj3258,poj1905,poj3122)<br>七.计算几何学.<br>(1)几何公式.<br>(2)叉积和点积的运用(如线段相交的判定,点到线段的距离等). (poj2031,poj1039)</div>
<div>(3)多边型的简单算法(求面积)和相关判定(点在多边型内,多边型是否相交)<br>(poj1408,poj1584)<br>(4)凸包. (poj2187,poj1113)<br>－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br>中级:<br>一.基本算法:<br>(1)C++的标准模版库的应用. (poj3096,poj3007)<br>(2)较为复杂的模拟题的训练(poj3393,poj1472,poj3371,poj1027,poj2706)<br>二.图算法:<br>(1)差分约束系统的建立和求解. (poj1201,poj2983)<br>(2)最小费用最大流(poj2516,poj2195)<br>(3)双连通分量(poj2942)<br>(4)强连通分支及其缩点.(poj2186)<br>(5)图的割边和割点(poj3352)<br>(6)最小割模型、网络流规约(poj3308, )<br>三.数据结构.<br>(1)线段树. (poj2528,poj2828,poj2777,poj2886,poj2750)<br>(2)静态二叉检索树. (poj2482,poj2352)<br>(3)树状树组(poj1195,poj3321)<br>(4)RMQ. (poj3264,poj3368)<br>(5)并查集的高级应用. (poj1703,2492)<br>(6)KMP算法. (poj1961,poj2406)<br>四.搜索<br>(1)最优化剪枝和可行性剪枝<br>(2)搜索的技巧和优化 (poj3411,poj1724)<br>(3)记忆化搜索(poj3373,poj1691)</div>
<div>五.动态规划<br>(1)较为复杂的动态规划(如动态规划解特别的施行商问题等)<br>(poj1191,poj1054,poj3280,poj2029,poj2948,poj1925,poj3034)<br>(2)记录状态的动态规划. (POJ3254,poj2411,poj1185)<br>(3)树型动态规划(poj2057,poj1947,poj2486,poj3140)<br>六.数学<br>(1)组合数学:<br>1.容斥原理.<br>2.抽屉原理.<br>3.置换群与Polya定理(poj1286,poj2409,poj3270,poj1026).<br>4.递推关系和母函数.</div>
<div>(2)数学.<br>1.高斯消元法(poj2947,poj1487, poj2065,poj1166,poj1222)<br>2.概率问题. (poj3071,poj3440)<br>3.GCD、扩展的欧几里德(中国剩余定理) (poj3101)<br>(3)计算方法.<br>1.0/1分数规划. (poj2976)<br>2.三分法求解单峰(单谷)的极值.<br>3.矩阵法(poj3150,poj3422,poj3070)<br>4.迭代逼近(poj3301)<br>(4)随机化算法(poj3318,poj2454)<br>(5)杂题.<br>(poj1870,poj3296,poj3286,poj1095)<br>七.计算几何学.<br>(1)坐标离散化.<br>(2)扫描线算法(例如求矩形的面积和周长并,常和线段树或堆一起使用).<br>(poj1765,poj1177,poj1151,poj3277,poj2280,poj3004)<br>(3)多边形的内核(半平面交)(poj3130,poj3335)<br>(4)几何工具的综合应用.(poj1819,poj1066,poj2043,poj3227,poj2165,poj3429)<br>－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br>高级:<br>一.基本算法要求:<br>(1)代码快速写成,精简但不失风格<br>(poj2525,poj1684,poj1421,poj1048,poj2050,poj3306)<br>(2)保证正确性和高效性. poj3434<br>二.图算法:<br>(1)度限制最小生成树和第K最短路. (poj1639)<br>(2)最短路,最小生成树,二分图,最大流问题的相关理论(主要是模型建立和求解)</div>
<div>(poj3155, poj2112,poj1966,poj3281,poj1087,poj2289,poj3216,poj2446<br>(3)最优比率生成树. (poj2728)<br>(4)最小树形图(poj3164)<br>(5)次小生成树.<br>(6)无向图、有向图的最小环<br>三.数据结构.<br>(1)trie图的建立和应用. (poj2778)<br>(2)LCA和RMQ问题(LCA(最近公共祖先问题) 有离线算法(并查集+dfs) 和 在线算法</div>
<div>(RMQ+dfs)).(poj1330)<br>(3)双端队列和它的应用(维护一个单调的队列,常常在动态规划中起到优化状态转移<br>的<br>目的). (poj2823)<br>(4)左偏树(可合并堆).<br>(5)后缀树(非常有用的数据结构,也是赛区考题的热点).<br>(poj3415,poj3294)<br>四.搜索<br>(1)较麻烦的搜索题目训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426)</div>
<div>(2)广搜的状态优化:利用M进制数存储状态、转化为串用hash表判重、按位压缩存储<br>状态、双向广搜、A*算法. (poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)<br>(3)深搜的优化:尽量用位运算、一定要加剪枝、函数参数尽可能少、层数不易过大<br>、可以考虑双向搜索或者是轮换搜索、IDA*算法. (poj3131,poj2870,poj2286)<br>五.动态规划<br>(1)需要用数据结构优化的动态规划.<br>(poj2754,poj3378,poj3017)<br>(2)四边形不等式理论.<br>(3)较难的状态DP(poj3133)<br>六.数学<br>(1)组合数学.<br>1.MoBius反演(poj2888,poj2154)<br>2.偏序关系理论.<br>(2)博奕论.<br>1.极大极小过程(poj3317,poj1085)<br>2.Nim问题.<br>七.计算几何学.<br>(1)半平面求交(poj3384,poj2540)<br>(2)可视图的建立(poj2966)<br>(3)点集最小圆覆盖.<br>(4)对踵点(poj2079)<br>八.综合题.<br>(poj3109,poj1478,poj1462,poj2729,poj2048,poj3336,poj3315,poj2148,poj1263</div>
<img src ="http://www.cppblog.com/mtysblog/aggbug/137039.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/mtysblog/" target="_blank">_飞寒</a> 2010-12-20 21:20 <a href="http://www.cppblog.com/mtysblog/articles/137039.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>