锘??xml version="1.0" encoding="utf-8" standalone="yes"?>
--from <<Dark Knight>>
鍘熸枃錛歨ttp://jackyhds.wordpress.com/2010/01/21/imdb%E8%A2%AB%E5%A2%99/
聽聽2聽聽*聽SOUR:zju2589
聽聽3聽聽*聽ALGO:computational聽geomtry聽璁$畻騫抽潰涓婁笉閲嶅悎鐨刵涓渾褰㈡垚鐨勫尯鍩?br />聽聽4聽聽*聽鍩烘湰鐨勬柟娉曪紝濡傚浘鎵紺猴紝灝嗘墍鏈夊渾涔嬮棿鐨勪氦鐐逛綔涓虹偣錛屽皢鍦ㄥ悓涓涓渾涓婄殑鎵鏈変氦鐐逛箣闂寸殑寮т綔
聽聽5聽聽*聽涓鴻竟寤虹珛涓寮犳湁鍚戝浘錛屼箣鍚庡彲浠ュ埄鐢ㄥ鉤闈㈠浘鐨勬鎷夊畾鐞?br />聽聽6聽聽*聽聽聽聽聽聽聽聽聽聽聽V聽-聽E聽+聽F聽=聽2
聽聽7聽聽*聽鐢變簬V宸茬煡錛孍宸茬煡錛孎灝卞彲浠ユ眰鍑烘潵浜嗐?br />聽聽8聽聽*聽鐢變簬嬈ф媺瀹氱悊鏄涓寮犳棤鍚戣繛閫氬浘鎴愮珛鐨勶紝濡傛灉鍥炬湁澶氫釜榪為氬潡鐨勬椂鍊欓渶瑕佸嬈ф媺瀹氱悊鍋氫竴浜?br />聽聽9聽聽*聽淇敼銆傜敱浜庡涓湁鍚戝浘鐨勯潰鍏變韓鏈澶栬竟鐨勯潰錛屾墍浠ヨ鑱旈氬潡鐨勪釜鏁頒負n
聽10聽聽*聽V聽-聽E聽+聽F聽=聽2聽*聽n聽,聽浣嗘槸闇瑕佸噺鍘籲涓仈閫氬潡鍏變韓鐨勬渶澶у鉤闈?br />聽11聽聽*聽鎵浠ヂ燜聽=聽n聽+聽1聽+聽E聽-聽V;
聽12聽聽*聽DATE:聽2010騫綽?7鏈埪?8鏃ヂ犳槦鏈熷洓聽14:49:41聽CST
聽13聽聽*聽COMM:5
聽14聽聽*聽*/
聽15聽const聽int聽N聽=聽64;
聽16聽const聽double聽eps聽=聽1e-8;
聽17聽int聽n,聽vis[N],聽g[N][N];
聽18聽double聽r[N];
聽19聽struct聽point_t聽{
聽20聽聽聽聽聽double聽x,聽y;
聽21聽聽聽聽聽point_t(){}
聽22聽聽聽聽聽point_t(double聽a,聽double聽b){x聽=聽a,聽y聽=聽b;}聽
聽23聽}c[N];
聽24聽
聽25聽int聽dcmp(double聽x)聽{聽return聽(x聽>聽eps)聽-聽(x聽<聽-eps);}聽
聽26聽bool聽operator聽<聽(point_t聽a,point_t聽b)聽
聽27聽{
聽28聽聽聽if聽(dcmp(a.x聽-聽b.x))聽{
聽29聽聽聽聽聽聽聽return聽a.x聽<聽b.x;
聽30聽聽聽}
聽31聽聽聽return聽dcmp(a.y聽-聽b.y)聽<聽0;
聽32聽}
聽33聽
聽34聽point_t聽operator聽+聽(point_t聽a,聽point_t聽b)聽{聽return聽point_t(a.x+b.x,聽a.y+b.y);}
聽35聽point_t聽operator聽-聽(point_t聽a,聽point_t聽b)聽{聽return聽point_t(a.x-b.x,聽a.y-b.y);}
聽36聽double聽dist(point_t聽a,聽point_t聽b)聽{聽return聽hypot(a.x-b.x,聽a.y-b.y);}
聽37聽double聽sqr(double聽x)聽{聽return聽x聽*聽x;}
聽38聽point_t聽normal(point_t聽a)聽{聽return聽point_t(a.x聽/聽hypot(a.x,聽a.y),聽a.y聽/聽hypot(a.x,聽a.y));}
聽39聽point_t聽scale(point_t聽a,聽double聽fac)聽{聽return聽point_t(a.x聽*聽fac,聽a.y聽*聽fac);}
聽40聽bool聽intersect(point_t聽c1,聽double聽r1,聽point_t聽c2,聽double聽r2,聽point_t聽&a,聽point_t聽&b)
聽41聽{
聽42聽聽聽double聽d聽=聽dist(c1,聽c2);
聽43聽聽聽if聽(d聽<聽fabs(r1聽-聽r2)聽-聽eps聽||聽d聽>聽r1聽+聽r2聽+聽eps)聽{
聽44聽聽聽聽聽聽聽return聽false;
聽45聽聽聽}
聽46聽聽聽double聽len聽=聽(sqr(r1)聽-聽sqr(r2)聽+聽sqr(d))聽/聽2.0聽/聽d;
聽47聽聽聽double聽h聽=聽sqrt(sqr(r1)聽-聽sqr(len));
聽48聽聽聽point_t聽t聽=聽normal(c2聽-聽c1);
聽49聽聽聽point_t聽p聽=聽c1聽+聽scale(t,聽len);
聽50聽聽聽point_t聽v聽=聽scale(point_t(-t.y,聽t.x),聽h);
聽51聽聽聽a聽=聽p聽+聽v,聽b聽=聽p聽-v;
聽52聽聽聽return聽true;
聽53聽}
聽54聽
聽55聽void聽init()
聽56聽{
聽57聽聽聽int聽i;
聽58聽聽聽memset(g,聽0,聽sizeof(g));
聽59聽聽聽memset(vis,聽0,聽sizeof(vis));
聽60聽聽聽for聽(i聽=聽0;i聽<聽n;i++)聽{
聽61聽聽聽聽聽聽聽g[i][i]聽=聽1;
聽62聽聽聽}
聽63聽}
聽64聽
聽65聽int聽main()
聽66聽{
聽67聽聽聽int聽testcase,聽i,聽j,聽k;
聽68聽聽聽scanf("%d",聽&testcase);
聽69聽聽聽while聽(testcase--)聽{
聽70聽聽聽聽聽聽聽scanf("%d",聽&n);
聽71聽聽聽聽聽聽聽set聽<point_t>聽allpoint,聽p[64];
聽72聽聽聽聽聽聽聽for聽(i聽=聽0;i聽<聽n;i++)聽{
聽73聽聽聽聽聽聽聽聽聽聽聽scanf("%lf聽%lf聽%lf",聽&c[i].x,聽&c[i].y,聽&r[i]);
聽74聽聽聽聽聽聽聽}
聽75聽聽聽聽聽聽聽init();
聽76聽聽聽聽聽聽聽for聽(i聽=聽0;i聽<聽n;i++)聽{
聽77聽聽聽聽聽聽聽聽聽聽聽for聽(j聽=聽i聽+聽1;j聽<聽n;j++)聽{
聽78聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽point_t聽a,聽b;
聽79聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽if聽(intersect(c[i],聽r[i],聽c[j],聽r[j],聽a,聽b))聽{
聽80聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽allpoint.insert(a),聽allpoint.insert(b);
聽81聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽p[i].insert(a),聽p[i].insert(b);
聽82聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽p[j].insert(a),聽p[j].insert(b);
聽83聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽g[i][j]聽=聽g[j][i]聽=聽1;
聽84聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
聽85聽聽聽聽聽聽聽聽聽聽聽}
聽86聽聽聽聽聽聽聽}
聽87聽聽聽聽聽聽聽for聽(k聽=聽0;k聽<聽n;k++)聽{
聽88聽聽聽聽聽聽聽聽聽聽聽for聽(i聽=聽0;i聽<聽n;i++)聽{
聽89聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽for聽(j聽=聽0;j聽<聽n;j++)聽{
聽90聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽g[i][j]聽|=聽g[i][k]聽&聽g[k][j];
聽91聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
聽92聽聽聽聽聽聽聽聽聽聽聽}
聽93聽聽聽聽聽聽聽}
聽94聽聽聽聽聽聽聽int聽f聽=聽1;
聽95聽聽聽聽聽聽聽for聽(i聽=聽0;i聽<聽n;i++)聽{
聽96聽聽聽聽聽聽聽聽聽聽聽f聽+=聽p[i].size();
聽97聽聽聽聽聽聽聽聽聽聽聽if聽(!vis[i])聽{
聽98聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽f聽+=聽1;
聽99聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽for聽(j聽=聽0;j聽<聽n;j++)聽{
100聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽vis[j]聽|=聽g[i][j];
101聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
102聽聽聽聽聽聽聽聽聽聽聽}
103聽聽聽聽聽聽聽}
104聽聽聽聽聽聽聽f聽-=聽allpoint.size();
105聽聽聽聽聽聽聽printf("%d\n",聽f);
106聽聽聽}聽
107聽聽聽return聽0;
108聽}
109聽
110聽
聽2聽聽*聽SOUR:pku3334
聽3聽聽*聽ALGO:浜屽垎楂樺害錛屾眰姘村鉤綰垮拰澶氳竟褰㈢殑浜ょ偣錛屾眰鍑哄杈瑰艦闈㈢Н
聽4聽聽*聽DATE:聽2010騫綽?7鏈埪?7鏃ヂ犳槦鏈熶笁聽22:29:14聽CST
聽5聽聽*聽*/
聽6聽const聽int聽N聽=聽1024;
聽7聽struct聽point_t聽{
聽8聽聽聽聽聽double聽x,聽y;
聽9聽聽聽聽聽point_t聽(){}
10聽聽聽聽聽point_t聽(double聽a,聽double聽b){x聽=聽a,聽y聽=聽b;}
11聽}P[N],聽Q[N];
12聽int聽m,聽n,聽cp,聽cq;
13聽double聽area;
14聽
15聽point_t聽operator聽+聽(point_t聽a,聽point_t聽b)聽{聽return聽point_t(a.x聽+聽b.x,聽a.y聽+聽b.y);}
16聽point_t聽operator聽-聽(point_t聽a,聽point_t聽b)聽{聽return聽point_t(a.x聽-聽b.x,聽a.y聽-聽b.y);}
17聽double聽SQR(double聽x聽){聽return聽x聽*聽x;}
18聽double聽dist(point_t聽a)聽{聽return聽sqrt(SQR(a.x)聽+聽SQR(a.y));}
19聽double聽dist(point_t聽a,聽point_t聽b)聽{聽return聽dist(a-b);}
20聽double聽cross_mul(point_t聽a,聽point_t聽b)聽{聽return聽a.x聽*聽b.y聽-聽a.y聽*聽b.x;}
21聽const聽double聽eps聽=聽1e-10;
22聽
23聽double聽calcu(point_t聽p[],聽int聽n,聽int聽cusp,聽double聽h)
24聽{
25聽聽聽double聽ans聽=聽0;
26聽聽聽int聽i,聽j,聽k,聽beg聽=聽0,聽end聽=聽n聽-聽1;
27聽聽聽if聽(h聽<=聽p[cusp].y)聽{
28聽聽聽聽聽聽聽return聽0;
29聽聽聽}
30聽聽聽for聽(i聽=聽0;i聽<聽cusp;i聽++)聽{
31聽聽聽聽聽聽聽if聽(p[i].y聽>=聽h聽&&聽h聽>=聽p[i+1].y)聽{
32聽聽聽聽聽聽聽聽聽聽聽beg聽=聽i;break;
33聽聽聽聽聽聽聽}
34聽聽聽}
35聽聽聽for聽(i聽=聽n聽-聽2;i聽>=聽cusp;i--)聽{
36聽聽聽聽聽聽聽if聽(p[i].y聽<=聽h聽&&聽h聽<=聽p[i+1].y)聽{
37聽聽聽聽聽聽聽聽聽聽聽end聽=聽i;break;
38聽聽聽聽聽聽聽}
39聽聽聽}
40聽
41聽聽聽point_t聽a聽=聽point_t(p[beg].x聽+聽(h聽-聽p[beg].y)聽*聽(p[beg+1].x聽-聽p[beg].x)
42聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽/聽(p[beg+1].y聽-聽p[beg].y)聽,聽h);
43聽聽聽point_t聽b聽=聽point_t(p[end].x聽+聽(h聽-聽p[end].y)聽*聽(p[end+1].x聽-聽p[end].x)
44聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽/聽(p[end+1].y聽-聽p[end].y)聽,聽h);
45聽聽聽ans聽+=聽cross_mul(a,聽p[beg+1])聽+聽cross_mul(p[end],聽b)聽+聽cross_mul(b,聽a);
46聽聽聽for聽(i聽=聽beg聽+聽1;i聽<=聽end聽-聽1;i++)聽{
47聽聽聽聽聽聽聽ans聽+=聽cross_mul(p[i],聽p[i+1]);
48聽聽聽}
49聽聽聽return聽fabs(ans聽/聽2.0);
50聽}
51聽
52聽int聽main()
53聽{
54聽聽聽int聽testcase,聽i;
55聽聽聽scanf("%d",聽&testcase);
56聽聽聽while聽(testcase--)聽{
57聽聽聽聽聽聽聽scanf("%lf",聽&area);
58聽聽聽聽聽聽聽scanf("%d",聽&m);聽for聽(i聽=聽0;i聽<聽m;i++)聽{聽scanf("%lf聽%lf",聽&P[i].x,聽&P[i].y);聽}
59聽聽聽聽聽聽聽scanf("%d",聽&n);聽for聽(i聽=聽0;i聽<聽n;i++)聽{聽scanf("%lf聽%lf",聽&Q[i].x,聽&Q[i].y);聽}
60聽聽聽聽聽聽聽for聽(i聽=聽1;i聽<聽m-1;i++)聽{
61聽聽聽聽聽聽聽聽聽聽聽if聽(P[i-1].y聽>=聽P[i].y聽&&聽P[i].y聽<=聽P[i+1].y)聽{
62聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽cp聽=聽i;
63聽聽聽聽聽聽聽聽聽聽聽}
64聽聽聽聽聽聽聽}
65聽聽聽聽聽聽聽for聽(i聽=聽1;i聽<聽n-1;i++)聽{
66聽聽聽聽聽聽聽聽聽聽聽if聽(Q[i-1].y聽>=聽Q[i].y聽&&聽Q[i].y聽<=聽Q[i+1].y)聽{
67聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽cq聽=聽i;
68聽聽聽聽聽聽聽聽聽聽聽}
69聽聽聽聽聽聽聽}
70聽聽聽聽聽聽聽double聽L聽=聽min(P[cp].y聽,聽Q[cq].y),
71聽聽聽聽聽聽聽聽聽聽聽聽聽聽R聽=聽min(min(P[0].y,聽P[m聽-聽1].y)聽,聽min(Q[0].y,聽Q[n聽-聽1].y))聽;
72聽聽聽聽聽聽聽while聽(L聽+聽eps聽<聽R)聽{
73聽聽聽聽聽聽聽聽聽聽聽double聽mid聽=聽(L聽+聽R)聽/聽2.0;
74聽聽聽聽聽聽聽聽聽聽聽double聽A聽=聽calcu(P,聽m,聽cp,聽mid)聽+聽calcu(Q,聽n,聽cq,聽mid);
75聽聽聽聽聽聽聽聽聽聽聽//printf("h聽=聽%.3f,聽A聽=聽%.3f\n",聽mid,聽A);
76聽聽聽聽聽聽聽聽聽聽聽if聽(A聽<=聽area)聽{
77聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽L聽=聽mid;
78聽聽聽聽聽聽聽聽聽聽聽}else聽{
79聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽R聽=聽mid;
80聽聽聽聽聽聽聽聽聽聽聽}
81聽聽聽聽聽聽聽}
82聽聽聽聽聽聽聽printf("%.3f\n",聽L);
83聽聽聽}
84聽聽聽return聽0;
85聽}
86聽
87聽
88聽
![]()
聽2聽
聽3聽struct聽point_t聽{
聽4聽聽聽聽聽double聽x,聽y;
聽5聽}p[N],聽Y[N];
聽6聽
聽7聽double聽sqr(double聽x)聽{聽return聽x聽*聽x;}
聽8聽bool聽cmp1(const聽point_t聽&a,聽const聽point_t聽&b)
聽9聽{
10聽聽聽if聽(a.x聽!=聽b.x)聽{
11聽聽聽聽聽聽聽return聽a.x聽<聽b.x;
12聽聽聽}
13聽聽聽return聽a.y聽<聽b.y;
14聽}
15聽
16聽bool聽cmp2(const聽point_t聽&a,const聽point_t聽&b)
17聽{
18聽聽聽if聽(a.y聽!=聽b.y)聽{
19聽聽聽聽聽聽聽return聽a.y聽<聽b.y;
20聽聽聽}
21聽聽聽return聽a.x聽<聽b.x;
22聽}
23聽
24聽const聽double聽inf聽=聽1e100;
25聽double聽dist(point_t聽a,point_t聽b)聽{聽return聽sqrt(sqr(a.x聽-聽b.x)聽+聽sqr(a.y聽-聽b.y));}
26聽int聽top;
27聽
28聽double聽divide(int聽beg,聽int聽end)
29聽{
30聽聽聽double聽ans聽=聽inf;
31聽聽聽int聽i,j;
32聽聽聽if聽(end聽<聽beg聽+聽3)聽{
33聽聽聽聽聽聽聽for聽(i聽=聽beg;i聽<=聽end;i++)聽{
34聽聽聽聽聽聽聽聽聽聽聽for聽(j聽=聽i聽+聽1;j聽<=聽end;j++)聽{
35聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ckmin(ans,聽dist(p[i],聽p[j]));
36聽聽聽聽聽聽聽聽聽聽聽}
37聽聽聽聽聽聽聽}
38聽聽聽聽聽聽聽return聽ans;
39聽聽聽}
40聽聽聽int聽mid聽=聽(beg聽+聽end)聽>>聽1,聽cnt;
41聽聽聽ckmin(ans,聽divide(beg,聽mid));
42聽聽聽ckmin(ans,聽divide(mid聽+聽1,聽end));
43聽聽聽for聽(i聽=聽beg,聽top聽=聽0;i聽<=聽end;i++)聽{
44聽聽聽聽聽聽聽if聽(fabs(p[i].x聽-聽p[mid].x)聽<聽ans)聽{
45聽聽聽聽聽聽聽聽聽聽聽Y[top++]聽=聽p[i];
46聽聽聽聽聽聽聽}
47聽聽聽}
48聽聽聽sort(Y,聽Y聽+聽top,聽cmp2);
49聽聽聽for聽(i聽=聽0;i聽<聽top;i++)聽{
50聽聽聽聽聽聽聽for聽(cnt聽=聽0,j聽=聽i聽+聽1;j聽<聽top聽&&聽cnt聽<聽7;cnt++,聽j++)聽{
51聽聽聽聽聽聽聽聽聽聽聽ckmin(ans,聽dist(Y[i],聽Y[j]));
52聽聽聽聽聽聽聽}
53聽聽聽}
54聽聽聽return聽ans;
55聽}
56聽
57聽int聽n;
58聽void聽proc()
59聽{
60聽聽聽int聽i,j,k;
61聽聽聽sort(p,聽p聽+聽n,聽cmp1);
62聽聽聽double聽ans聽=聽divide(0,聽n聽-聽1);
63聽聽聽printf("%.2f\n",聽ans/2.0);
64聽}
65聽
66聽int聽main()
67聽{
68聽聽聽int聽i,j,k;
69聽聽聽while聽(scanf("%d",聽&n)聽==聽1聽&&聽n)聽{
70聽聽聽聽聽聽聽for聽(i聽=聽0;i聽<聽n;i++)聽{
71聽聽聽聽聽聽聽聽聽聽聽scanf("%lf聽%lf",聽&p[i].x,聽&p[i].y);
72聽聽聽聽聽聽聽}
73聽聽聽聽聽聽聽proc();
74聽聽聽}
75聽聽聽return聽0;
76聽}
77聽![]()
![]()
http://www.cse.unsw.edu.au/~lambert/java/3d/hull.html
鐜板湪鐨勪富瑕侀棶棰樺氨鏄紝涓鐩存墍鏈夐潰鐨勬硶鍚戦噺錛屽浣曟洿鏂板嚫鍖呫?br />娉曞悜閲忕偣涔樹竴涓悜閲忥紝鍙互寰楀埌榪欎釜鍚戦噺鍦ㄦ硶鍚戦噺涓婄殑鍋忕Щ錛屽鏋滆繖涓亸縐繪槸姝g殑錛岃鏄庤繖涓悜閲忕浉鍏崇殑鐐瑰湪闈㈢殑涓婃柟錛岃礋鐨勬槸涓嬫柟錛屾墍浠ュ彧瑕佹壘鍒頒竴鏉¤竟鍏寵仈鐨勪袱涓潰鐨勭偣縐槸涓姝d竴璐熷嵆鍙?br />
娉ㄦ剰榪欓噷鐨勬墍鏈夐潰閮芥槸鐢變笁涓偣緇勬垚錛屼笖鏄湁搴忕殑錛屾瘡涓竟鍙璁板綍涓ゆ錛屼竴嬈¢『鏃墮拡錛屼竴嬈¢嗘椂閽堛?br />榪欓噷涓嶈兘浣跨敤int錛屾暟鍊煎お澶т細瓚婄晫銆?br />
聽2聽const聽int聽N聽=聽1024;
聽3聽struct聽F聽{
聽4聽聽聽聽聽int聽v[4];
聽5聽聽聽聽聽F(){}
聽6聽聽聽聽聽F(int聽a,int聽b,int聽c){聽v[0]聽=聽a,聽v[1]聽=聽b,聽v[2]聽=聽c,聽v[3]聽=聽v[0];}
聽7聽};
聽8聽
聽9聽struct聽point_t聽{
10聽聽聽聽聽double聽x,聽y,聽z;
11聽聽聽聽聽point_t聽(){}
12聽聽聽聽聽point_t聽(double聽a,聽double聽b,聽double聽c){x聽=聽a,聽y聽=聽b,聽z聽=聽c;}
13聽};
14聽point_t聽operator聽+(point_t聽a,聽point_t聽b)聽{聽return聽point_t聽(a.x聽+聽b.x,聽a.y聽+聽b.y,聽a.z聽+聽b.z);}
15聽point_t聽operator聽-(point_t聽a,聽point_t聽b)聽{聽return聽point_t聽(a.x聽-聽b.x,聽a.y聽-聽b.y,聽a.z聽-聽b.z);}
16聽
17聽double聽dot_mul(point_t聽a,聽point_t聽b)聽{聽return聽a.x聽*聽b.x聽+聽a.y聽*聽b.y聽+聽a.z聽*聽b.z;}
18聽point_t聽cross_mul(point_t聽a,point_t聽b)
19聽{
20聽聽聽聽聽return聽point_t聽(a.y*b.z聽-聽b.y*a.z聽,
21聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽a.z*b.x聽-聽b.z*a.x聽,
22聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽a.x*b.y聽-聽b.x*a.y);
23聽}
24聽
25聽double聽area(point_t聽a,聽point_t聽b)
26聽{
27聽聽聽point_t聽v聽=聽cross_mul(a,聽b);
28聽聽聽return聽sqrt(0.0聽+聽v.x聽*聽v.x聽+聽v.y聽*聽v.y聽+聽v.z聽*聽v.z)聽/聽2;
29聽}
30聽
31聽point_t聽p[N];
32聽int聽vis[N][N],聽n;
33聽
34聽int聽main()
35聽{
36聽聽聽int聽i,聽j,聽k;
37聽聽聽scanf("%d",聽&n);
38聽聽聽for聽(i聽=聽0;i聽<聽n;i++)聽{
39聽聽聽聽聽聽聽scanf("%lf聽%lf聽%lf",聽&p[i].x,聽&p[i].y,聽&p[i].z);
40聽聽聽}
41聽聽聽vector<F>聽cur;
42聽聽聽cur.pb(F(0,聽1,聽2)),聽cur.pb(F(2,聽1,聽0));
43聽聽聽for聽(i聽=聽3;i聽<聽n;i++)聽{
44聽聽聽聽聽聽聽vector<F>聽next;
45聽聽聽聽聽聽聽for聽(j聽=聽0;j聽<聽cur.size();j++)聽{
46聽聽聽聽聽聽聽聽聽聽聽F聽f聽=聽cur[j];
47聽聽聽聽聽聽聽聽聽聽聽point_t聽v聽=聽cross_mul(p[f.v[1]]聽-聽p[f.v[0]],
48聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽p[f.v[2]]聽-聽p[f.v[1]]);
49聽聽聽聽聽聽聽聽聽聽聽int聽val聽=聽dot_mul(v,聽p[i]聽-聽p[f.v[1]])聽<聽0聽?聽-1聽:聽1;
50聽聽聽聽聽聽聽聽聽聽聽if聽(val聽<聽0)聽{
51聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽next.pb(f);
52聽聽聽聽聽聽聽聽聽聽聽}
53聽聽聽聽聽聽聽聽聽聽聽for聽(k聽=聽0;k聽<聽3;k++)聽{
54聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽if聽(vis[f.v[k+1]][f.v[k]]聽==聽0)聽{
55聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽vis[f.v[k]][f.v[k+1]]聽=聽val;
56聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}else聽{ //http://m.shnenglu.com/schindlerlee
57聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽if聽(vis[f.v[k+1]][f.v[k]]聽!=聽val)聽{
58聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽if聽(val聽>聽0)聽{
59聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽next.pb(F(f.v[k],聽f.v[k+1],聽i));
60聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}else聽{
61聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽next.pb(F(f.v[k+1],聽f.v[k],聽i));
62聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
63聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
64聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽vis[f.v[k+1]][f.v[k]]聽=聽0;
65聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
66聽聽聽聽聽聽聽聽聽聽聽}
67聽聽聽聽聽聽聽}
68聽聽聽聽聽聽聽cur聽=聽next;
69聽聽聽}
70聽聽聽double聽ans聽=聽0;
71聽聽聽for聽(i聽=聽0;i聽<聽cur.size();i++)聽{
72聽聽聽聽聽聽聽F聽f聽=聽cur[i];
73聽聽聽聽聽聽聽ans聽+=聽area(p[f.v[0]]聽-聽p[f.v[1]],聽p[f.v[2]]聽-聽p[f.v[1]]);
74聽聽聽}
75聽聽聽printf("%.3f\n",聽ans);
76聽聽聽return聽0;
77聽}
榪樻湁灝辨槸瑕佹敞鎰忥紝int鍨嬫鏁幫紝鍙崇Щ琛?錛岃礋鏁板彸縐繪槸琛?鐨勶紝
聽聽2聽/*
聽聽3聽聽*聽SOUR:spoj1182
聽聽4聽聽*聽ALGO:dp,聽number聽theory,聽binary聽search
聽聽5聽聽*聽DATE:聽2010騫綽?6鏈埪?8鏃ヂ犳槦鏈熶簩聽19:47:51聽CST
聽聽6聽聽*聽COMM:5
聽聽7聽聽*聽*/
聽聽8聽#include<iostream>
聽聽9聽#include<cstdio>
聽10聽#include<cstdlib>
聽11聽#include<cstring>
聽12聽#include<algorithm>
聽13聽#include<queue>
聽14聽#include<vector>
聽15聽#include<map>
聽16聽using聽namespace聽std;
聽17聽#define聽pb(x)聽push_back(x)
聽18聽//#define聽X聽first
聽19聽//#define聽Y聽second
聽20聽typedef聽vector聽<聽int聽>vi;
聽21聽typedef聽pair聽<聽int,聽int聽>pii;
聽22聽typedef聽long聽long聽LL;
聽23聽typedef聽unsigned聽long聽long聽ULL;
聽24聽typedef聽unsigned聽int聽uint;
聽25聽
聽26聽template聽<class聽T>聽void聽ckmin(T聽&a,T聽b)聽{聽if聽(a聽>聽b)聽{聽a聽=聽b;聽}聽}
聽27聽template聽<class聽T>聽void聽ckmax(T聽&a,T聽b)聽{聽if聽(a聽<聽b)聽{聽a聽=聽b;聽}聽}
聽28聽int聽countbit(int聽n)聽{聽return聽n聽==聽0聽?聽0聽:聽1聽+聽countbit(n聽&聽(n聽-聽1));聽}
聽29聽
聽30聽const聽int聽maxint聽=聽0x7fffffff;
聽31聽const聽long聽long聽max64聽=聽0x7fffffffffffffffll;
聽32聽int聽cnt[40][40],聽sum[40];
聽33聽int聽X,聽Y,聽K;
聽34聽
聽35聽void聽pre()
聽36聽聽聽聽聽聽//綆楀嚭cnt[闀垮害][鍚灝戜釜1]鐨勬柟妗堟暟
聽37聽{
聽38聽聽聽int聽i,j;
聽39聽聽聽cnt[0][0]聽=聽1;
聽40聽聽聽for聽(i聽=聽1;i聽<=聽32;i++)聽{
聽41聽聽聽聽聽聽聽cnt[i][0]聽=聽cnt[i-1][0];
聽42聽聽聽聽聽聽聽for聽(j聽=聽1;j聽<=聽32;j++)聽{
聽43聽聽聽聽聽聽聽聽聽聽聽cnt[i][j]聽=聽cnt[i-1][j]聽+聽cnt[i-1][j-1];
聽44聽聽聽聽聽聽聽}
聽45聽聽聽}
聽46聽}
聽47聽
聽48聽int聽num[40],聽top;
聽49聽int聽summ(uint聽X,聽int聽R,聽bool聽flag聽=聽false)
聽50聽{
聽51聽聽聽memset(num,聽0,聽sizeof(num));
聽52聽聽聽top聽=聽1;
聽53聽聽聽while聽(X)聽{
聽54聽聽聽聽聽聽聽num[top++]聽=聽X聽&聽1;
聽55聽聽聽聽聽聽聽X聽>>=聽1;
聽56聽聽聽}
聽57聽聽聽if聽(flag)聽{
聽58聽聽聽聽聽聽聽for聽(int聽i聽=聽1;i聽<=聽top;i++)聽{
聽59聽聽聽聽聽聽聽聽聽聽聽if聽(num[i]聽==聽0)聽{
聽60聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽num[i]聽=聽1;
聽61聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽for聽(int聽j聽=聽i聽-聽1;j聽>=聽1;j--)聽{
聽62聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽num[j]聽=聽0;
聽63聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
聽64聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽if聽(i聽==聽top)聽{聽top++;聽}
聽65聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽break;
聽66聽聽聽聽聽聽聽聽聽聽聽}
聽67聽聽聽聽聽聽聽}
聽68聽聽聽}
聽69聽聽聽int聽ans聽=聽0,聽one聽=聽0,聽i;
聽70聽聽聽for聽(i聽=聽top聽-聽1;i聽>=聽1;i--)聽{
聽71聽聽聽聽聽聽聽if聽(R聽>=聽one聽&&聽num[i]聽==聽1)聽{
聽72聽聽聽聽聽聽聽聽聽聽聽ans聽+=聽cnt[i聽-聽1][R聽-聽one];
聽73聽聽聽聽聽聽聽聽聽聽聽one++;
聽74聽聽聽聽聽聽聽}
聽75聽聽聽}
聽76聽聽聽return聽ans;
聽77聽}
聽78聽
聽79聽int聽summarize(uint聽X,聽uint聽Y,聽int聽digit)
聽80聽聽聽聽聽聽//[X,聽Y]聽涓?鐨勪釜鏁頒負digit鐨劼犳暟瀛椾釜鏁?/span>
聽81聽{聽return聽summ(Y,聽digit,聽1)聽-聽summ(X,聽digit,聽0);聽}
聽82聽
聽83聽void聽proc()
聽84聽{
聽85聽聽聽int聽i,聽j,聽one聽=聽-1;
聽86聽聽聽memset(sum,聽0,聽sizeof(sum));
聽87聽聽聽for聽(i聽=聽0;i聽<聽32;i++)聽{
聽88聽聽聽聽聽聽聽sum[i]聽=聽summarize(X,聽Y,聽i)聽;
聽89聽聽聽聽聽聽聽if聽(K聽聽>聽sum[i])聽{
聽90聽聽聽聽聽聽聽聽聽聽聽K聽-=聽sum[i];
聽91聽聽聽聽聽聽聽}else聽{
聽92聽聽聽聽聽聽聽聽聽聽聽one聽=聽i;
聽93聽聽聽聽聽聽聽聽聽聽聽break;
聽94聽聽聽聽聽聽聽}
聽95聽聽聽}
聽96聽聽聽if聽(Y聽<聽X)聽{聽swap(X,聽Y);聽}
聽97聽聽聽int聽left聽=聽X,聽right聽=聽Y;
聽98聽聽聽while聽(left聽<聽right)聽{聽//binary聽search聽the聽value聽expected
聽99聽聽聽聽聽聽聽int聽mid聽=聽(left聽+聽right聽+聽1)聽/聽2;
100聽聽聽聽聽聽聽if聽(summarize(X,聽mid,聽one)聽<=聽K)聽{
101聽聽聽聽聽聽聽聽聽聽聽left聽=聽mid;
102聽聽聽聽聽聽聽}else聽{
103聽聽聽聽聽聽聽聽聽聽聽right聽=聽mid聽-聽1;
104聽聽聽聽聽聽聽}
105聽聽聽}
106聽聽聽while聽(countbit(left)聽!=聽one)聽{聽left聽--;聽}聽//聽attention
107聽
108聽聽聽int聽ans聽=聽0;
109聽聽聽for聽(i聽=聽0;i聽<聽32;i++)聽{
110聽聽聽聽聽聽聽if聽(left聽&聽(1聽<<聽i))聽{
111聽聽聽聽聽聽聽聽聽聽聽ans聽|=聽1聽<<聽i;
112聽聽聽聽聽聽聽}
113聽聽聽}
114聽聽聽printf("%d\n",聽ans);
115聽}
116聽
117聽int聽main()
118聽{
119聽聽聽int聽i,聽j,聽testcase;
120聽聽聽pre();
121聽聽聽scanf("%d",聽&testcase);
122聽聽聽while聽(testcase--聽)聽{
123聽聽聽聽聽聽聽scanf("%d聽%d聽%d",聽&X,聽&Y,聽&K);
124聽聽聽聽聽聽聽proc();
125聽聽聽}
126聽聽聽return聽0;
127聽}
128聽
闇瑕侀潪甯告敞鎰忚竟鐣屾潯浠剁殑澶勭悊.
聽聽2聽聽*聽SOUR:ural聽1057
聽聽3聽聽*聽ALGO:number聽theory聽and聽binary聽tree,聽in聽other聽word聽enumerate聽the聽highest聽digit,
聽聽4聽聽*聽聽聽聽聽聽and聽use聽dp聽to聽reduce聽calculation.
聽聽5聽聽*聽DATE:聽2010騫綽?6鏈埪?8鏃ヂ犳槦鏈熶簩聽16:44:45聽CST
聽聽6聽聽*聽COMM:
聽聽7聽聽*聽*/
聽聽8聽
聽聽9聽using聽namespace聽std;
聽10聽#define聽pb(x)聽push_back(x)
聽11聽#define聽X聽first
聽12聽#define聽Y聽second
聽13聽typedef聽vector聽<聽int聽>vi;
聽14聽typedef聽pair聽<聽int,聽int聽>pii;
聽15聽typedef聽long聽long聽LL;
聽16聽template聽<class聽T>聽void聽ckmin(T聽&a,T聽b)聽{聽if聽(a聽>聽b)聽{聽a聽=聽b;聽}聽}
聽17聽template聽<class聽T>聽void聽ckmax(T聽&a,T聽b)聽{聽if聽(a聽<聽b)聽{聽a聽=聽b;聽}聽}
聽18聽int聽countbit(int聽n)聽{聽return聽n聽==聽0聽?聽0聽:聽1聽+聽countbit(n聽&聽(n聽-聽1));聽}
聽19聽
聽20聽const聽int聽maxint聽=聽0x7fffffff;
聽21聽const聽long聽long聽max64聽=聽0x7fffffffffffffffll;
聽22聽int聽X,聽Y,聽K,聽B;
聽23聽int聽cnt[40][40];
聽24聽
聽25聽void聽pre聽()
聽26聽{
聽27聽聽聽int聽i,聽j;
聽28聽聽聽cnt[0][0]聽=聽1;
聽29聽聽聽for聽(i聽=聽1;i聽<=聽32;i++)聽{
聽30聽聽聽聽聽聽聽cnt[i][0]聽=聽cnt[i-1][0];
聽31聽聽聽聽聽聽聽for聽(j聽=聽1;j聽<=聽32;j++)聽{
聽32聽聽聽聽聽聽聽聽聽聽聽cnt[i][j]聽=聽cnt[i-1][j]聽+聽cnt[i-1][j-1];
聽33聽聽聽聽聽聽聽}
聽34聽聽聽}
聽35聽}
聽36聽
聽37聽void聽changeBase(int聽X,聽int聽num[],聽int聽&top)
聽38聽{
聽39聽聽聽top聽=聽1;
聽40聽聽聽while聽(X聽>聽0)聽{
聽41聽聽聽聽聽聽聽num[top++]聽=聽X聽%聽B;
聽42聽聽聽聽聽聽聽X聽/=聽B;
聽43聽聽聽}
聽44聽}
聽45聽
聽46聽void聽plus_one(int聽num[],聽int聽&top)
聽47聽{
聽48聽聽聽int聽i,j;
聽49聽聽聽for聽(i聽=聽1;i聽<=聽top;i++)聽{
聽50聽聽聽聽聽聽聽if聽(num[i]聽==聽0)聽{
聽51聽聽聽聽聽聽聽聽聽聽聽num[i]聽=聽1;
聽52聽聽聽聽聽聽聽聽聽聽聽for聽(j聽=聽i聽-聽1;j聽>=聽1;j--)聽{
聽53聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽num[j]聽=聽0;
聽54聽聽聽聽聽聽聽聽聽聽聽}
聽55聽聽聽聽聽聽聽聽聽聽聽break;
聽56聽聽聽聽聽聽聽}
聽57聽聽聽}
聽58聽聽聽if聽(i聽==聽top)聽{
聽59聽聽聽聽聽聽聽top++;
聽60聽聽聽}
聽61聽}
聽62聽
聽63聽bool聽floor(int聽num[],聽int聽top)
聽64聽{
聽65聽聽聽int聽i,j;
聽66聽聽聽for聽(i聽=聽top聽-聽1;i聽>=聽1;i--)聽{
聽67聽聽聽聽聽聽聽if聽(num[i]聽>聽1)聽{
聽68聽聽聽聽聽聽聽聽聽聽聽for聽(j聽=聽i;j聽>=聽1;j--)聽{
聽69聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽num[j]聽=聽1;
聽70聽聽聽聽聽聽聽聽聽聽聽}
聽71聽聽聽聽聽聽聽聽聽聽聽break;
聽72聽聽聽聽聽聽聽}
聽73聽聽聽}
聽74聽聽聽if聽(i聽>=聽1)聽{
聽75聽聽聽聽聽聽聽return聽true;
聽76聽聽聽}
聽77聽聽聽return聽false;
聽78聽}
聽79聽
聽80聽int聽num[40],聽top;
聽81聽int聽proc(int聽X,bool聽flag聽=聽false)
聽82聽{
聽83聽聽聽memset(num,聽0,聽sizeof(num));
聽84聽聽聽changeBase(X,聽num,聽top);
聽85聽聽聽if聽(floor(num,聽top)聽||聽flag)聽{
聽86聽聽聽聽聽聽聽plus_one(num,聽top);
聽87聽聽聽}
聽88聽
聽89聽聽聽int聽ans聽=聽0,聽sum聽=聽0,聽i;
聽90聽聽聽for聽(i聽=聽top聽-聽1;i聽>=聽1;i--)聽{
聽91聽聽聽聽聽聽聽if聽(K聽>=聽sum聽&&聽num[i]聽==聽1)聽{
聽92聽聽聽聽聽聽聽聽聽聽聽ans聽+=聽cnt[i-1][K聽-聽sum];
聽93聽聽聽聽聽聽聽聽聽聽聽sum++;
聽94聽聽聽聽聽聽聽}
聽95聽聽聽}
聽96聽聽聽return聽ans;
聽97聽}
聽98聽
聽99聽int聽main()
100聽{
101聽聽聽pre();
102聽聽聽int聽num[40],聽top,聽ans;
103聽聽聽cin聽>>聽X聽>>聽Y聽>>聽K聽>>聽B;
104聽聽聽ans聽=聽proc(Y,聽1)聽-聽proc(X);
105聽聽聽cout聽<<聽ans聽<<聽endl;
106聽聽聽return聽0;
107聽}
n = 6: 6 5 3 2 4 1
鎴戝彂鐜板鏋滄妸6鍘繪帀錛屾崲涓?錛屽啀緲諱笅鍘誨氨鏄?銆?br />浜庢槸鎴戞兂濂藉儚鍙互閫掓帹錛岀劧鍚庡氨榪囦簡銆傘?br />POJ bug鐪熷錛屼笅闈㈢殑浠g爜絎竴嬈′氦TLE錛岀浜屾375MS聽聽 聽
聽2聽const聽int聽N聽=聽50100;
聽3聽int聽a[N],n,len;
聽4聽int聽main()
聽5聽{
聽6聽聽聽int聽i,j,k;
聽7聽聽聽scanf("%d",&n);
聽8聽聽聽a[1]聽=聽1,len聽=聽1;
聽9聽聽聽for聽(k聽=聽2;k聽<=聽n;k++)聽{
10聽聽聽聽聽聽聽i聽=聽len;
11聽聽聽聽聽聽聽while聽(i聽>聽1)聽{
12聽聽聽聽聽聽聽聽聽聽聽a[i]聽=聽a[i/2];
13聽聽聽聽聽聽聽聽聽聽聽i聽/=聽2;
14聽聽聽聽聽聽聽}
15聽聽聽聽聽聽聽a[1]聽=聽k;
16聽聽聽聽聽聽聽a[++len]聽=聽1;
17聽聽聽}
18聽聽聽for聽(i聽=聽1;i聽<=聽len;i++)聽{
19聽聽聽聽聽聽聽printf("%d聽",a[i]);
20聽聽聽}
21聽聽聽putchar(10);
22聽聽聽return聽0;
23聽}
24聽
A:涓夎褰袱杈逛箣鍜屽ぇ浜庣涓夎竟
B:鏆村姏鎼滀竴涓?br />C:妯℃嫙
聽2聽scanf("%d\n",&n);
聽3聽for聽(i聽=聽0;i聽<聽n;i++)聽{
聽4聽聽聽scanf("%d",a聽+聽i);
聽5聽}
聽6聽int聽L聽=聽0,R聽=聽n聽-聽1,time1聽=聽0,time2聽=聽0,ans1聽=聽0,ans2聽=聽0;
聽7聽while聽(L聽<=聽R)聽{
聽8聽聽聽if聽(time1聽<聽time2)聽{
聽9聽聽聽聽聽聽聽time1聽+=聽a[L++]聽,ans1聽++;
10聽聽聽}else聽if聽(time1聽>聽time2)聽{
11聽聽聽聽聽聽聽time2聽+=聽a[R--]聽,ans2聽++;
12聽聽聽}else聽{
13聽聽聽聽聽聽聽time1聽+=聽a[L++]聽,ans1聽++;
14聽聽聽}
15聽}
16聽printf("%d聽%d\n",ans1,ans2);
D:棰樼洰鏀逛簡錛屽拰姣旇禌鐨勬椂鍊欎笉涓鏍蜂簡錛屾暟鎹寖鍥村緢灝忥紝dfs
E:RMQ + binary_search
緇欏嚭n涓暟鍜屼竴涓寖鍥碖銆?br />鎵懼嚭鏈闀跨殑榪炵畫鐨勬暟錛屽叾涓渶澶у煎拰鏈灝忓肩殑宸笉瓚呰繃K
涓涓洿瑙夌殑鎯蟲硶鏄?br />for(i = 0;i < n;i++) {
聽聽 聽int L = a[i],R = a[i];
聽聽 聽for (j = i + 1;j < n && R - L <= K;j++) {
聽聽 聽聽聽 聽鏇存柊L,R
聽聽 聽}
聽聽 聽鏇存柊answer
}
浣嗘槸n鏄?0^5,n^2浼氳秴鏃躲?br />姹傚尯闂存渶澶у兼渶灝忓煎彲浠ョ敤rmq錛孫(nlogn)棰勫鐞嗭紝O(1)鐨勫緱鍒般?br />涓瀹氬瓨鍦ㄤ竴涓猨錛屼嬌寰梐 [i ... j]鍚堟硶,a[j + 1 ..n]涓嶅悎娉曘?br />濂界殑鏂規硶鏄簩鍒嗘悳绱㈠埌榪欎釜j錛屾按鐐圭殑鏂規硶鍙互浠庡悗寰鍓嶆壘j銆?
RMQ 鍙互綰挎鏍戯紝涔熷彲浠parseTable
鎬誨鏉傚害O(nlogn)
codeforces 鍙互鐪嬩唬鐮侊紝鎯崇湅鐨勪細鍘繪壘鍚с傝繖閲岀殑浜屽垎鎼滄湁trick錛屾眰鐨勬槸upper_bound涓嶆槸涓鑸啓鐨刲ower_bound,闇瑕佽皟鏁淬?br />
鐒跺悗鎴戜篃灝卞啓浜嗕釜璁板繂璇濇悳绱紝涔熻繃浜嗐傘?br />
聽2聽#include<iostream>
聽3聽#include<cstdio>
聽4聽#include<cstdlib>
聽5聽#include<cstring>
聽6聽#include<algorithm>
聽7聽using聽namespace聽std;
聽8聽typedef聽long聽long聽LL;
聽9聽const聽int聽maxint聽=聽0x7fffffff;
10聽const聽long聽long聽max64聽=聽0x7fffffffffffffffll;
11聽const聽int聽Debug聽=聽1;
12聽const聽int聽M聽=聽228;
13聽const聽int聽N聽=聽13;
14聽const聽int聽inf聽=聽1000000;
15聽
16聽int聽dp[M][N][N][N][N],聽m,聽n,聽a[N],聽b[N];
17聽void聽ckmin(int聽&a,聽int聽b)聽{聽if聽(a聽>聽b)聽{聽a聽=聽b;聽}聽}
18聽int聽dfs(int聽balloon,int聽p0,int聽p1,int聽p2,int聽p3)
19聽{
20聽聽聽if聽(dp[balloon][p0][p1][p2][p3]聽<聽inf)聽{
21聽聽聽聽聽聽聽return聽dp[balloon][p0][p1][p2][p3];
22聽聽聽}
23聽聽聽if聽(balloon聽>=聽m)聽{
24聽聽聽聽聽聽聽return聽0;
25聽聽聽}
26聽聽聽for聽(int聽i聽=聽1;i聽<=聽n;i++)聽{
27聽聽聽聽聽聽聽if聽(b[i]聽==聽1聽&&聽(p0聽==聽i))聽{聽continue;聽}
28聽聽聽聽聽聽聽if聽(b[i]聽==聽2聽&&聽(p0聽==聽i聽||聽p1聽==聽i))聽{聽continue;聽}
29聽聽聽聽聽聽聽if聽(b[i]聽==聽3聽&&聽(p0聽==聽i聽||聽p1聽==聽i聽||聽p2聽==聽i))聽{聽continue;聽}
30聽聽聽聽聽聽聽if聽(b[i]聽==聽4聽&&聽(p0聽==聽i聽||聽p1聽==聽i聽||聽p2聽==聽i聽||聽p3聽==聽i))聽{聽continue;聽}
31聽聽聽聽聽聽聽ckmin(dp聽[balloon][p0][p1][p2][p3]聽,聽dfs(balloon聽+聽a[i],i,p0,p1,p2)聽+聽1);
32聽聽聽}
33聽聽聽if聽(dp聽[balloon][p0][p1][p2][p3]聽>=聽inf)聽{
34聽聽聽聽聽聽聽dp聽[balloon][p0][p1][p2][p3]聽=聽dfs(balloon,0,p0,p1,p2)聽+聽1;
35聽聽聽}
36聽聽聽return聽dp聽[balloon][p0][p1][p2][p3];
37聽}
38//http://m.shnenglu.com/schindlerlee
39聽int聽main()
40聽{
41聽聽聽聽聽int聽i,聽j,聽k,聽p[4],聽tmp;
42聽聽聽聽聽memset(dp,127,sizeof(dp));
43聽聽聽聽聽//printf("%d\n",dp[0][0][0][0][0]);
44聽聽聽聽聽scanf("%d聽%d",聽&m,聽&n);
45聽聽聽聽聽for聽(i聽=聽1;聽i聽<=聽n;聽i++)聽{
46聽聽聽聽聽聽聽聽聽scanf("%d聽%d",聽a聽+聽i,聽b聽+聽i);
47聽聽聽聽聽}
48聽
49聽聽聽聽聽printf("%d\n",聽聽聽聽dfs(0,0,0,0,0));
50聽聽聽聽聽return聽0;
51聽}
52聽