sicily

Sicily8544

一条从原点出发的射线，求所有和它相交的圆的相交弦的和的最大值。从Y轴开始共24*60个时刻，旋转一周。每个时刻转的角度为360°/(24*60)。直接一个一个枚举判断即可。#include #include #include #include #include #include #include usingnamespacestd; structcircle { doublex,y,r; };
immiao·2014-03-25 12:00

Sicily8539(单调队列)

#include #include #include #include usingnamespacestd; structp { intdata; intpos; }C[200005]; inta[200005]; intb[200005]; intmain() { intn; inti; intT=0; while(1) { T++; dequeQ; scanf("%d",&n); if(!
immiao·2014-03-21 19:00

Sicily10481(并查集)

xyL其实表示x和y不同，xyT表示x和y相同。rank[x]表示第x个元素和其根节点的关系，rank[x]=1表示和根节点不同，rank[x]=0表示和根节点相同。特别注意当B集合合并到A集合的时候，B集合的根节点的rank值需要更新，且其所有子节点也可能需要更新，在路径压缩的时候进行特殊处理确保子节点能够得到正确的rank值。#include #include #include #includ
immiao·2014-03-19 17:00

Sicily10359(优先队列)

#include #include #include #include #include usingnamespacestd; structobject { intw,v; }A[300005]; intbag[300005]; boolcmp1(structobjecta,structobjectb) { returna.w,cmp2>Q; scanf("%d%d",&n,&m); for(
immiao·2014-03-14 19:00

Sicily10330

#include #include #include #include #include usingnamespacestd; intmain() { intn,m; scanf("%d%d",&n,&m); if(n%m==0) printf("0\n"); else { if(m%n==0) printf("%d\n",(m/n-1)*n); else { intans=0; inttota
immiao·2014-03-13 20:00

Sicily10399(DP)

dp[i]表示从1到i所花费的最小值。当新添加元素i时，需要放置一个wifi点在它和i之前的点的中间，或直接设立在它的位置上，遍历一遍取最小的值。#include #include #include #include usingnamespacestd; constintmaxn=100000000; intmain() { intn,a,b; doubledp[2005]; inti,j; i
immiao·2014-03-12 12:00

Sicily10393(二分)

先将每个字符串按照字典序升序排序，存入strmin。再将每个字符串按照字典序降序排序，存入strmax。然后对于字符串i，其lowest的值为该字符串的字典序升序在strmax中的位置。                 其hightest的值为该字符串的字典序降序在strmin中的位置再减去1，因为在strmin中的该位置前还有一个是该字符串的字典序升序，不应该考虑进去。#include #inc
immiao·2014-03-11 16:00

Sicily 2014年每周一赛第一场

比较苦逼、爆0了、、总结一下吧、1000.CuttingSausages        TimeLimit:1sec  MemoryLimit:256MBDescriptionMirkohasgivenuponthedifficultcoachjobandswitchedtofoodtastinginstead.Havingskippedbreakfastlikeaprofessionalconn
y990041769·2014-03-02 10:00

sicily 1036. Crypto Columns

但是刷sicily就先不顾忌这些了。
xueweiwu·2014-01-13 22:39

sicily 1151. 魔板[Special judge]

  题目是和1150一样的，但是把深度最大为N的条件去掉了。所以搜索空间大了很多。但是时间限制和内存限制又没增大，所以如果按照1150的方法去写，肯定会超时的。所以，剪枝是必要的。  可以判断，其实如果按照之前的代码，会出现很多重复判断的情况，如AA是和空操作是一样的结果，所以，怎么减少这些重复的判断就是我们剪枝要做的事情。  这里，还使用到了康拓展开。其实不用康拓展开应该也可以，只是更耗内存而已
xueweiwu·2014-01-13 19:40

sicily 1150. 简单魔板

  水题一条，但可以通过此题学习宽搜或深搜，然后通过和1151的比较，学习搜索中剪枝的作用。  宽搜中可以在递归的一开始就先检测是否搜到目标值（如下面贴上来的代码），也可以在将候选节点入队时检查。但如果是在入队时检查的话记得要注意在初始节点入队时检查初始节点是否就已经是目标值。  一开始犯的错误就是红色字体标出的错误。因此自己写多几个测试用例测试自己的代码，全部测试用例如下：45876412338
xueweiwu·2014-01-13 19:51

sicily 1046. Plane Spotting 排序 结构

  这道题不用结构体或类的话做起来挺累的。而且做完这道题才发现我C和C++很多语法和函数都忘了。像sort(p,p+cnt)这样的排序函数都不会用了，差点就自己写冒泡排序了。而符号重写就完全忘了，毕竟很少有语言会有这种功能开放了。  其中新写的代码用了师兄的结构体和比较符号“ #include usingnamespacestd; classPeriodNode{ intst; intend; d
xueweiwu·2014-01-04 21:41

sicily 1035. DNA matching 字符串

  这么简单的题都出错了。因为忘了把检查过的结果给清除了，所以可能导致重复计算。  比如AT,TA,AT这样的输入，应该只能组成一组，如果组完后没有丢弃AT,TA，就会导致检查完AT后继续检查TA，然后将已经使用过的TA去和AT做匹配！  先贴下错误代码：#include usingnamespacestd; boolmatch_c(chara,charb){ if(a=='A'&&b=='T')
xueweiwu·2014-01-04 19:04

sicily 1027. MJ, Nowhere to Hide 字符串

  就是简单的字符串比较和排序。  一开始看到之前写的代码是用了map，觉得没必要用map，只需要pair就可以了。等做完才发现原来输出要求是要按id的字典序排序的，而map在插入的过程中就自动排序了。所以最后还是用了map，省得自己写排序^_^。  先贴下之前的代码，应该是不熟悉string（可能是混淆了C和C++的string导致错误又懒得去解决，所以使用了数字的比较，写得很繁琐，但很可爱地处
xueweiwu·2014-01-04 19:03

sicily 1021. Couples 栈

  利用栈可以巧妙的解决该问题。  之所以可以用栈可以解决，关键在于想通就算是第1个和第N个是配对，一直删除配对下去，也是会在队列的中间就有个配对的，所以栈的使用并不会和排队排成圈这一特性有冲突。应该想通即使出现第1个和第N个配对这样的特例，也是可以从中间向两边散开消除，到最后栈还是会出现空的情况。  一开始忘了STL里面有栈，使用数组去模拟栈（数组模拟栈的要点在于存储栈顶所在的索引位置）。如下：
xueweiwu·2014-01-04 18:00

sicily 1020. Big Integer 大数求模

http://blog.163.com/hong_feiy/blog/static/207325071201282324736756/回想小学怎么做除法可以帮助理解大数求模#include #include usingnamespacestd; intdiv(stringx,intb){ intr,k; for(k=0;k>t; for(i=0;i>n; m=1; for(j=0;j>b[j];
xueweiwu·2014-01-04 16:27

Sicily1350(并查集)

#include #include #include usingnamespacestd; intparent[1000005]; boolhash[1000005]; intgetpar(inta) { if(parent[a]!=a) parent[a]=getpar(parent[a]); returnparent[a]; } intmain() { intT; while(scanf(
immiao·2013-12-21 11:00

Sicily7145(二分)

#include #include #include #include #include #include usingnamespacestd; intA[100005],B[100005]; intsearch(intL1,intR1,intL2,intR2,intK) { if(L1>R1)returnB[L2+K-1]; if(L2>R2)returnA[L1+K-1]; intmidA
immiao·2013-12-20 10:00

Sicily1345(能量项链DP)

A[j][i]表示从j个珠子开始到j+i个珠子的能量最优值。(若j+i>=n-1则取余)比如对于样例数据(2,3)(3,5)(5,10)(10,2)。假定从0开始计，A[0][2]即(2,3)(3,5)(5,10)的最优值，可能先聚合(2,3)和(3,5)，再(2,5)和(5,10)聚合，也可能(3,5)和(5,10)先聚合，再(2,3)和(3,10)聚合。用A表示则为A[0][2]等于 A[0]
immiao·2013-12-13 21:00

Sicily2014

DP算法：#include #include usingnamespacestd; intmain() { intm,n; scanf("%d%d",&m,&n); intdp[305]={0}; inti,j; intA[10]; for(i=n;i>=1;i--) scanf("%d",&A[i]); //dp dp[0]=1; for(i=1;i=A[i]) dp[j]+=dp[j-A[
immiao·2013-12-11 14:00

Sicily2015

参考自：http://blog.csdn.net/lyhvoyage/article/details/12239757//Problem#:2015 //Submission#:2527950 //ThesourcecodeislicensedunderCreativeCommonsAttribution-NonCommercial-ShareAlike3.0UnportedLicense //U
immiao·2013-12-10 15:00

Sicily2011(预处理广搜)

题目包含多组测试数据，一开始没有注意直接广搜TLE，需要先进行预处理，记录好每个状态到达最终状态的路经长，最后直接输出才不会TLE。预处理从终点开始，反过来逆时针变换，便于记录路径长。用到了康托展开记录状态，用来判断是否被访问过。需要注意的是，这里在队列里存储的元素不是康托展开的数。若直接存储康托展开的数，则在进行状态转换时需要进行逆展开成数组再变换或者进行比较麻烦的处理。因此我在队列里直接存储的
immiao·2013-12-08 15:00

Sicily1781(广搜)

#include #include #include #include usingnamespacestd; intA[505][505]; intvstd[505][505]; intmain() { intT; scanf("%d",&T); while(T--) { memset(vstd,0,sizeof(vstd)); queueQ; queuepath; intu; intm,n;
immiao·2013-12-04 18:00

Sicily9564

用线段树做还是超时，百度了一下发现有简便算法。#include #include #include #include #include #include usingnamespacestd; intxmin[1000005]={0}; intxmax[1000005]={0}; intymin[1000005]={0}; intymax[1000005]={0}; intmain() { int
immiao·2013-12-03 20:00

Sicily1767(双线程动态规划)

NOIP2008传纸条，有点神奇的动态规划。重合时赋值为0，则不会出现重合的情况。#include #include #include #include usingnamespacestd; intdp[110][52][52]={{{0}}}; intmain() { intm,n; while(scanf("%d%d",&m,&n)!=EOF) { memset(dp,0,sizeof(dp)
immiao·2013-12-01 00:00

Sicily1154(快排)

#include #include usingnamespacestd; intpartition(int*A,intl,intr) { intx=A[r]; inti,j; inttemp; i=l-1; for(j=l;j<=r-1;j++) if(A[j]<=x) { i=i+1; temp=A[j]; A[j]=A[i]; A[i]=temp; } temp=A[i+1]; A[i+1]
immiao·2013-11-28 14:00

Sicily1428(DFS)

#include #include #include #include usingnamespacestd; charstr[55][55]; charA[55][55]; intvisited[55][55]; intans; intrecord; intlength; intcounter; voiddfs(intx,inty) { visited[x][y]=1; if(A[x+1][y
immiao·2013-11-28 10:00

Sicily 1685 Missile

DP，最长单调子序列的变形。#include intdp[1010][2]; intnums[1010]; intget_max(inta,intb){ if(a>b) returna; else returnb; } intmain(){ inti,j,n; intans; scanf("%d",&n); while(n!=0){ for(i=1;inums[i]) dp[i][0]=get_m
Detective_Xin·2013-11-22 11:00

Sicily9360(BFS无权图最短路径)

将hypertubes也当成一个顶点来考虑，存在vector[maxn]的后面。最终的结果除以2即可，算station再加上1。#include #include #include #include #definemaxn1005 usingnamespacestd; intmain() { intn,k,m; inti,j; intrecord[maxn+1000]={0}; intdis[m
immiao·2013-11-21 19:00

Sicily9359(广搜)

有点小复杂的广搜，一开始将每个砖头的一半作为一个数组元素来存储，后来发现不满足广搜的规则。因为在一个砖头内移动是不算移动距离的，这样就会导致有些距离长的状态先被扩展出来，到达终点时不满足最短路径。最后改成每个砖头作为一个数组元素来存储，用结构体。分奇数行和偶数行讨论，每个砖头可以向其他6个方向扩展，广搜得到答案。#include #include #include usingnamespaces
immiao·2013-11-17 12:00

Erupting volcano blows unbelievably perfect smoke rings

MotherNaturehasstillgotyoubeat.MountEtnainSicily,ItalytookalittlebreakfromeruptingtoblowO-shapedsmokeringshundredsoffeetindiametertomakeeverysmokerandpoth
mudxkx·2013-11-15 15:37

Sicily1211(矩阵相乘)

邻接矩阵相乘n次后得到矩阵A，A[i][j]表示从i出发恰好走过n条边到达j的情况数。#include #include usingnamespacestd; intmain() { intn,m,L; scanf("%d%d%d",&n,&m,&L); inti,j; intA[101][101]={{0}}; inta,b; for(i=1;i<=m;i++) { scanf("%d%d",
immiao·2013-11-14 20:00

Sicily1282(KMP算法)

注意母串的长度要开大一点。#include #include usingnamespacestd; intmain() { intn,m; while(scanf("%d",&m)!=EOF) { inti; intA[1000000],B[100000]; for(i=0;i<=m-1;i++) scanf("%d",&B[i]); scanf("%d",&n); for(i=0;i<=n-1;
immiao·2013-11-14 14:00

POJ2478 && Sicily1089(欧拉函数)

一直RuntimeError，最后把phi和f的声明放到main函数外面就行了，不懂。。#include #include usingnamespacestd; intphi[1000010]; longlongf[1000010]; intmain() { inti,j; for(i=1;i<=1000010;i++) phi[i]=i; for(i=2;i<=1000010;i+=2) p
immiao·2013-11-13 13:00

Sicily1083(最小生成树)

#include #include #include #include #include #include usingnamespacestd; intmain() { constintmax=100000000; intT; while(1) { intn,m; scanf("%d",&n); if(!n) break; scanf("%d",&m); inti,j,A[100][100]
immiao·2013-11-13 00:00

Sicily1090 && POJ2485(最小生成树)

#include #include #include #include #include #include usingnamespacestd; intmain() { constintmax=100000000; intT; scanf("%d",&T); while(T--) { intn; scanf("%d",&n); inti,j,A[500][500]; intd[500]; b
immiao·2013-11-12 19:00

Sicily1218

给WA脑残了，一直WA。#include #include usingnamespacestd; intmain() { intN,M; while(scanf("%d",&N)!=EOF) { scanf("%d",&M); intcounter=0; intL[100000],R[100000]; intdiv=2; intleft,right; while(1) { if(div%2==
immiao·2013-11-12 15:00

Sicily9162(单调队列)

先排序再维护每个区间的最小值。#include #include #include #include usingnamespacestd; structS { intdata; intpos; }dis[1000000]; intmain() { constintmaxn=1000000000; intN,K; dequeQ; scanf("%d%d",&N,&K); inti; intA[1
immiao·2013-11-08 21:00

大大

2013-10-14:Sicily3718.批改作业2013-10-14:Sicily3499.分数统计2013-10-14:Sicily3497.水仙花数2013-10-14:Sicily3496.鸡兔同笼
ljb_blog·2013-10-14 17:00

Sicily1828

#include #include #include usingnamespacestd; intmain() { intT; scanf("%d",&T); while(T--) { intdp[500][500]; ints1[500],s2[500]; intdis[500][500]; inti,j; intn,m; scanf("%d%d",&n,&m); for(i=0;i<=n
immiao·2013-10-13 21:00

Sicily1091

#include intmain() { intT; scanf("%d",&T); while(T--) { intn; intA[50000]; inti; intdp1[50000]={0}; intdp2[50000]={0}; intdp3[50000]={0}; scanf("%d",&n); dp1[0]=A[0]; for(i=0;iA[i]) dp1[i]=A[i]+dp1[
immiao·2013-10-12 15:00

Sicily 1448. Antimonotonicity

题目的意思跟Missile是一样的（见上篇），数据量变大而已。A之。代码：#include #include usingnamespacestd; #definemaxn30009 #definemax(a,b)a>b?a:b intt,n; intdp[maxn],a[maxn]; intmain(){ scanf("%d",&t); while(t--){ scanf("%d",&n);
linhan8·2013-10-01 18:00

Sicily 1685. Missile

有一种聪明的反导系统，可以“一上一下”地飞。那么，给定一个数组表示一堆导弹的飞行高度，求最多能打掉多少导弹。好吧，求一个 “最长颠簸子序列”。模仿“最长上升子序列”的动态规划解法，dp[i]表示“以第i个数结尾的颠簸序列”最长的长度。根据前面的dp[j](j #include usingnamespacestd; #definemaxn1509 #definemax(a,b)a>b?a:b in
linhan8·2013-10-01 18:00

Sicily 1563. GECKO

题目背景挺有趣的，但，是个水题。。。。一面墙上有好多格子，每个格子有很多蚊子，一只壁虎想吃尽可能多的蚊子。它的法定移动方法如图，很2B。求问它最多可以吃到多少只蚊子。动态规划可以解决，在每个格子，可以吃到最多dp[i][j]只蚊子，那这个值，只可能从上一行的邻近格子得到，无后效性，dp吧。代码：#include #include #include usingnamespacestd; #defin
linhan8·2013-10-01 18:00

Sicily 1902. Counting Problem

这题碉堡了。给一个N*N的棋盘，让你放皇后。要求：1、每行有且只有2个Queen；2、每列有且只有2个Queen；规定：如果两个棋盘，经过行交换和列交换，可以互相转换，那这两个局面等价。目标：给N，求出可以有多少种摆法（局面）。分析：这个题目，乍一看真的很无从下手。但是看到提示那个“规定”，这个等价提示了什么呢？在“行交换”和“列交换”的过程里， 什么是不变的？既然行和列的排列是自由的，那他们之间
linhan8·2013-10-01 18:00

Sicily 1564. HOUSING

给个整数x，把它分解成不小于5的整数和，有多少种分法。容量是x， 物品依次是 从5开始的整数 。。。 可以重复取，那就是——完全背包。要锻炼自己，把问题规约到典型模型的能力，这是最基本的。代码：#include #include usingnamespacestd; #definemaxn109 intdp[maxn]; //dp[i][j]在数字i面前，空余量j时，共有方案数目 intmain(
linhan8·2013-10-01 18:00

Sicily 1888. Circular Sequence

题目给一个整数序列，让你想象它们是首尾相连的一个圈，让你求一段，使得这段内的和最大。SegmentSum最大。其实，这种Segment可以有2种情况——一种是，没有跨越头尾的；另一种是跨过头尾的。前者，只需要用一个O（n）的经典dp就可以求出来。（思路就是，假如以上一位结尾的段和小于0，那么这一位就不必连续了，自己开个头算了。）后者，转化成，求一个段和最小的，再用总和去减掉。把所有数取相反数后，变
linhan8·2013-10-01 18:00

[Sicily] sicily 1091. Maximum Sum

题意：给一个数列，求一种分割方法分出两个子序列，使得两部分的和最大。那，可以用dynamicprogramming的办法做。用DP的思想预处理出2个数组c和d，c[i]----从前往后数到第i个数，可以取得的连续和最大子序列的和。d[i]----从后往前。。。。然后就枚举一遍了咯。代码：#include usingnamespacestd; #definemaxn50009 #definemax(
linhan8·2013-10-01 18:00

Sicily 1121. Tri Tiling

DescriptionInhowmanywayscanyoutilea3xn rectanglewith2x1dominoes?Hereisasampletilingofa3x12rectangle.InputInputconsistsofseveraltestcasesfollowedbyalinecontaining -1.Eachtestcaseisalinecontaininganinte
hewei0241·2013-09-26 14:00

Sicily 1158. Pick numbers

DescriptionGivenamatrixofsizeM*N,theelementsofwhichareintegernumbersfrom-10to10.Youtaskistogofromthetop-leftcorner(1,1)tothebottom-rightcorner(M,N).Youcanonlymoverightordown,andyoucannotgooutofthematr
hewei0241·2013-09-24 21:00
上一页 6 7 8 9 10 11 12 13 下一页
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他