Last active
August 29, 2015 14:02
-
-
Save lychees/803f6e6a61c0f393660a to your computer and use it in GitHub Desktop.
ACM-ICPC Regional Asia Changchun 2013 Onsite
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** Micro Mezz Macro Flation -- Overheated Economy ., Last Update: May. 7th 2014 **/ //{ | |
/** Header .. **/ //{ | |
#pragma comment(linker, "/STACK:36777216") | |
//#pragma GCC optimize ("O2") | |
#define LOCAL | |
//#include "testlib.h" | |
#include <functional> | |
#include <algorithm> | |
#include <iostream> | |
#include <fstream> | |
#include <sstream> | |
#include <iomanip> | |
#include <numeric> | |
#include <cstring> | |
#include <climits> | |
#include <cassert> | |
#include <complex> | |
#include <cstdio> | |
#include <string> | |
#include <vector> | |
#include <bitset> | |
#include <queue> | |
#include <stack> | |
#include <cmath> | |
#include <ctime> | |
#include <list> | |
#include <set> | |
#include <map> | |
//#include <tr1/unordered_set> | |
//#include <tr1/unordered_map> | |
//#include <array> | |
using namespace std; | |
#define REP(i, n) for (int i=0;i<n;++i) | |
#define FOR(i, a, b) for (int i=a;i<b;++i) | |
#define DWN(i, b, a) for (int i=b-1;i>=a;--i) | |
#define REP_1(i, n) for (int i=1;i<=n;++i) | |
#define FOR_1(i, a, b) for (int i=a;i<=b;++i) | |
#define DWN_1(i, b, a) for (int i=b;i>=a;--i) | |
#define REP_C(i, n) for (int n____=n,i=0;i<n____;++i) | |
#define FOR_C(i, a, b) for (int b____=b,i=a;i<b____;++i) | |
#define DWN_C(i, b, a) for (int a____=a,i=b-1;i>=a____;--i) | |
#define REP_N(i, n) for (i=0;i<n;++i) | |
#define FOR_N(i, a, b) for (i=a;i<b;++i) | |
#define DWN_N(i, b, a) for (i=b-1;i>=a;--i) | |
#define REP_1_C(i, n) for (int n____=n,i=1;i<=n____;++i) | |
#define FOR_1_C(i, a, b) for (int b____=b,i=a;i<=b____;++i) | |
#define DWN_1_C(i, b, a) for (int a____=a,i=b;i>=a____;--i) | |
#define REP_1_N(i, n) for (i=1;i<=n;++i) | |
#define FOR_1_N(i, a, b) for (i=a;i<=b;++i) | |
#define DWN_1_N(i, b, a) for (i=b;i>=a;--i) | |
#define REP_C_N(i, n) for (int n____=(i=0,n);i<n____;++i) | |
#define FOR_C_N(i, a, b) for (int b____=(i=0,b);i<b____;++i) | |
#define DWN_C_N(i, b, a) for (int a____=(i=b-1,a);i>=a____;--i) | |
#define REP_1_C_N(i, n) for (int n____=(i=1,n);i<=n____;++i) | |
#define FOR_1_C_N(i, a, b) for (int b____=(i=a,b);i<=b____;++i) | |
#define DWN_1_C_N(i, b, a) for (int a____=(i=b,a);i>=a____;--i) | |
#define ECH(it, A) for (__typeof(A.begin()) it=A.begin(); it != A.end(); ++it) | |
#define REP_S(i, str) for (char*i=str;*i;++i) | |
#define REP_L(i, hd, suc) for (int i=hd;i;i=suc[i]) | |
#define REP_G(i, u) REP_L(i,hd[u],suc) | |
#define REP_SS(x, s) for (int x=s;x;x=(x-1)&s) | |
#define DO(n) for ( int ____n = n; ____n-->0; ) | |
#define REP_2(i, j, n, m) REP(i, n) REP(j, m) | |
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m) | |
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l) | |
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l) | |
#define REP_4(i, j, k, ii, n, m, l, nn) REP(i, n) REP(j, m) REP(k, l) REP(ii, nn) | |
#define REP_4_1(i, j, k, ii, n, m, l, nn) REP_1(i, n) REP_1(j, m) REP_1(k, l) REP_1(ii, nn) | |
#define ALL(A) A.begin(), A.end() | |
#define LLA(A) A.rbegin(), A.rend() | |
#define CPY(A, B) memcpy(A, B, sizeof(A)) | |
#define INS(A, P, B) A.insert(A.begin() + P, B) | |
#define ERS(A, P) A.erase(A.begin() + P) | |
#define LBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define UBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define CTN(T, x) (T.find(x) != T.end()) | |
#define SZ(A) int((A).size()) | |
#define PB push_back | |
#define MP(A, B) make_pair(A, B) | |
#define PTT pair<T, T> | |
#define Ts *this | |
#define rTs return Ts | |
#define fi first | |
#define se second | |
#define re real() | |
#define im imag() | |
#define Rush for(int ____T=RD(); ____T--;) | |
#define Display(A, n, m) { \ | |
REP(i, n){ \ | |
REP(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m-1] << endl; \ | |
} \ | |
} | |
#define Display_1(A, n, m) { \ | |
REP_1(i, n){ \ | |
REP_1(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m] << endl; \ | |
} \ | |
} | |
typedef long long LL; | |
//typedef long double DB; | |
typedef double DB; | |
typedef unsigned uint; | |
typedef unsigned long long uLL; | |
typedef vector<int> VI; | |
typedef vector<char> VC; | |
typedef vector<string> VS; | |
typedef vector<LL> VL; | |
typedef vector<DB> VF; | |
typedef set<int> SI; | |
typedef set<string> SS; | |
typedef map<int, int> MII; | |
typedef map<string, int> MSI; | |
typedef pair<int, int> PII; | |
typedef pair<LL, LL> PLL; | |
typedef vector<PII> VII; | |
typedef vector<VI> VVI; | |
typedef vector<VII> VVII; | |
template<class T> inline T& RD(T &); | |
template<class T> inline void OT(const T &); | |
//inline int RD(){int x; return RD(x);} | |
inline LL RD(){LL x; return RD(x);} | |
inline DB& RF(DB &); | |
inline DB RF(){DB x; return RF(x);} | |
inline char* RS(char *s); | |
inline char& RC(char &c); | |
inline char RC(); | |
inline char& RC(char &c){scanf(" %c", &c); return c;} | |
inline char RC(){char c; return RC(c);} | |
//inline char& RC(char &c){c = getchar(); return c;} | |
//inline char RC(){return getchar();} | |
template<class T> inline T& RDD(T &); | |
inline LL RDD(){LL x; return RDD(x);} | |
template<class T0, class T1> inline T0& RD(T0 &x0, T1 &x1){RD(x0), RD(x1); return x0;} | |
template<class T0, class T1, class T2> inline T0& RD(T0 &x0, T1 &x1, T2 &x2){RD(x0), RD(x1), RD(x2); return x0;} | |
template<class T0, class T1, class T2, class T3> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3){RD(x0), RD(x1), RD(x2), RD(x3); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); return x0;} | |
template<class T0, class T1> inline void OT(const T0 &x0, const T1 &x1){OT(x0), OT(x1);} | |
template<class T0, class T1, class T2> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2){OT(x0), OT(x1), OT(x2);} | |
template<class T0, class T1, class T2, class T3> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3){OT(x0), OT(x1), OT(x2), OT(x3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5, const T6 &x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);} | |
inline char& RC(char &a, char &b){RC(a), RC(b); return a;} | |
inline char& RC(char &a, char &b, char &c){RC(a), RC(b), RC(c); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d){RC(a), RC(b), RC(c), RC(d); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e){RC(a), RC(b), RC(c), RC(d), RC(e); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g); return a;} | |
inline DB& RF(DB &a, DB &b){RF(a), RF(b); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c){RF(a), RF(b), RF(c); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d){RF(a), RF(b), RF(c), RF(d); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e){RF(a), RF(b), RF(c), RF(d), RF(e); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f, DB &g){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g); return a;} | |
inline void RS(char *s1, char *s2){RS(s1), RS(s2);} | |
inline void RS(char *s1, char *s2, char *s3){RS(s1), RS(s2), RS(s3);} | |
template<class T0,class T1>inline void RDD(T0&a, T1&b){RDD(a),RDD(b);} | |
template<class T0,class T1,class T2>inline void RDD(T0&a, T1&b, T2&c){RDD(a),RDD(b),RDD(c);} | |
template<class T> inline void RST(T &A){memset(A, 0, sizeof(A));} | |
template<class T> inline void FLC(T &A, int x){memset(A, x, sizeof(A));} | |
template<class T> inline void CLR(T &A){A.clear();} | |
template<class T0, class T1> inline void RST(T0 &A0, T1 &A1){RST(A0), RST(A1);} | |
template<class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2){RST(A0), RST(A1), RST(A2);} | |
template<class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3){RST(A0), RST(A1), RST(A2), RST(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);} | |
template<class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x){FLC(A0, x), FLC(A1, x);} | |
template<class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x);} | |
template<class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x), FLC(A6, x);} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, less<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(stack<T> &S){while (!S.empty()) S.pop();} | |
template<class T0, class T1> inline void CLR(T0 &A0, T1 &A1){CLR(A0), CLR(A1);} | |
template<class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2){CLR(A0), CLR(A1), CLR(A2);} | |
template<class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);} | |
template<class T> inline void CLR(T &A, int n){REP(i, n) CLR(A[i]);} | |
template<class T> inline bool EPT(T &a){return a.empty();} | |
template<class T> inline T& SRT(T &A){sort(ALL(A)); return A;} | |
template<class T, class C> inline T& SRT(T &A, C B){sort(ALL(A), B); return A;} | |
template<class T> inline T& RVS(T &A){reverse(ALL(A)); return A;} | |
template<class T> inline T& UNQQ(T &A){A.resize(unique(ALL(A))-A.begin());return A;} | |
template<class T> inline T& UNQ(T &A){SRT(A);return UNQQ(A);} | |
//} | |
/** Constant List .. **/ //{ | |
const int MOD = int(1e9) + 7; | |
const int INF = 0x3f3f3f3f; | |
const LL INFF = 0x3f3f3f3f3f3f3f3fLL; | |
const DB EPS = 1e-9; | |
const DB OO = 1e20; | |
const DB PI = acos(-1.0); //M_PI; | |
const int dx[] = {-1, 0, 1, 0}; | |
const int dy[] = {0, 1, 0, -1}; | |
//} | |
/** Add On .. **/ //{ | |
// <<= '0. Nichi Joo ., //{ | |
template<class T> inline T& checkMin(T &a,const T b){if (b<a) a=b;return a;} | |
template<class T> inline T& checkMax(T &a,const T b){if (a<b) a=b;return a;} | |
template<class T> inline T& checkMin(T &a, T &b, const T x){checkMin(a, x), checkMin(b, x);return a;} | |
template<class T> inline T& checkMax(T &a, T &b, const T x){checkMax(a, x), checkMax(b, x);return a;} | |
template <class T, class C> inline T& checkMin(T& a, const T b, C c){if (c(b,a)) a = b;return a;} | |
template <class T, class C> inline T& checkMax(T& a, const T b, C c){if (c(a,b)) a = b;return a;} | |
template<class T> inline T min(T a, T b, T c){return min(min(a, b), c);} | |
template<class T> inline T max(T a, T b, T c){return max(max(a, b), c);} | |
template<class T> inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));} | |
template<class T> inline T max(T a, T b, T c, T d){return max(max(a, b), max(c, d));} | |
template<class T> inline T min(T a, T b, T c, T d, T e){return min(min(min(a,b),min(c,d)),e);} | |
template<class T> inline T max(T a, T b, T c, T d, T e){return max(max(max(a,b),max(c,d)),e);} | |
template<class T> inline T sqr(T a){return a*a;} | |
template<class T> inline T cub(T a){return a*a*a;} | |
template<class T> inline T ceil(T x, T y){return (x - 1) / y + 1;} | |
template<class T> T abs(T x){return x>0?x:-x;} | |
inline int sgn(DB x){return x < -EPS ? -1 : x > EPS;} | |
inline int sgn(DB x, DB y){return sgn(x - y);} | |
inline DB cos(DB a, DB b, DB c){return (sqr(a)+sqr(b)-sqr(c))/(2*a*b);} | |
inline DB cot(DB x){return 1./tan(x);}; | |
inline DB sec(DB x){return 1./cos(x);}; | |
inline DB csc(DB x){return 1./sin(x);}; | |
//} | |
// <<= '1. Bitwise Operation ., //{ | |
namespace BO{ | |
inline bool _1(int x, int i){return bool(x&1<<i);} | |
inline bool _1(LL x, int i){return bool(x&1LL<<i);} | |
inline LL _1(int i){return 1LL<<i;} | |
inline LL _U(int i){return _1(i) - 1;}; | |
inline int reverse_bits(int x){ | |
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa); | |
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc); | |
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0); | |
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00); | |
x = ((x >>16) & 0x0000ffff) | ((x <<16) & 0xffff0000); | |
return x; | |
} | |
inline LL reverse_bits(LL x){ | |
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL); | |
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL); | |
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL); | |
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL); | |
x = ((x >>16) & 0x0000ffff0000ffffLL) | ((x <<16) & 0xffff0000ffff0000LL); | |
x = ((x >>32) & 0x00000000ffffffffLL) | ((x <<32) & 0xffffffff00000000LL); | |
return x; | |
} | |
template<class T> inline bool odd(T x){return x&1;} | |
template<class T> inline bool even(T x){return !odd(x);} | |
template<class T> inline T low_bit(T x) {return x & -x;} | |
template<class T> inline T high_bit(T x) {T p = low_bit(x);while (p != x) x -= p, p = low_bit(x);return p;} | |
template<class T> inline T cover_bit(T x){T p = 1; while (p < x) p <<= 1;return p;} | |
template<class T> inline int cover_idx(T x){int p = 0; while (_1(p) < x ) ++p; return p;} | |
inline int clz(int x){return __builtin_clz(x);} | |
inline int clz(LL x){return __builtin_clzll(x);} | |
inline int ctz(int x){return __builtin_ctz(x);} | |
inline int ctz(LL x){return __builtin_ctzll(x);} | |
inline int lg2(int x){return !x ? -1 : 31 - clz(x);} | |
inline int lg2(LL x){return !x ? -1 : 63 - clz(x);} | |
inline int low_idx(int x){return !x ? -1 : ctz(x);} | |
inline int low_idx(LL x){return !x ? -1 : ctz(x);} | |
inline int high_idx(int x){return lg2(x);} | |
inline int high_idx(LL x){return lg2(x);} | |
inline int parity(int x){return __builtin_parity(x);} | |
inline int parity(LL x){return __builtin_parityll(x);} | |
inline int count_bits(int x){return __builtin_popcount(x);} | |
inline int count_bits(LL x){return __builtin_popcountll(x);} | |
} using namespace BO;//} | |
//} | |
/** I/O Accelerator Interface .. **/ //{ | |
#define g (c=getchar()) | |
#define d isdigit(g) | |
#define p x=x*10+c-'0' | |
#define n x=x*10+'0'-c | |
#define pp l/=10,p | |
#define nn l/=10,n | |
template<class T> inline T& RD(T &x){ | |
char c;while(!d);x=c-'0';while(d)p; | |
return x; | |
} | |
template<class T> inline T& RDD(T &x){ | |
char c;while(g,c!='-'&&!isdigit(c)); | |
if (c=='-'){x='0'-g;while(d)n;} | |
else{x=c-'0';while(d)p;} | |
return x; | |
} | |
inline DB& RF(DB &x){ | |
//scanf("%lf", &x); | |
char c;while(g,c!='-'&&c!='.'&&!isdigit(c)); | |
if(c=='-')if(g=='.'){x=0;DB l=1;while(d)nn;x*=l;} | |
else{x='0'-c;while(d)n;if(c=='.'){DB l=1;while(d)nn;x*=l;}} | |
else if(c=='.'){x=0;DB l=1;while(d)pp;x*=l;} | |
else{x=c-'0';while(d)p;if(c=='.'){DB l=1;while(d)pp;x*=l;}} | |
return x; | |
} | |
#undef nn | |
#undef pp | |
#undef n | |
#undef p | |
#undef d | |
#undef g | |
inline char* RS(char *s){ | |
//gets(s); | |
scanf("%s", s); | |
return s; | |
} | |
LL last_ans; int Case; template<class T> inline void OT(const T &x){ | |
//printf("Case #%d: ", ++Case); | |
//printf("%lld\n", x); | |
//printf("%.9f\n", x); | |
printf("%d\n", x); | |
//cout << x << endl; | |
//last_ans = x; | |
} | |
//} | |
//}/* .................................................................................................................................. */ | |
const int N = int(1e6) + 9; | |
char str[N]; | |
int main(){ | |
Rush{ | |
int n, m; RD(n, m); RS(str); | |
REP(i, n){ | |
REP(j, m) printf("%c", str[i*m+j]); | |
puts(""); | |
} | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** Micro Mezz Macro Flation -- Overheated Economy ., Last Update: May. 7th 2014 **/ //{ | |
/** Header .. **/ //{ | |
#pragma comment(linker, "/STACK:36777216") | |
//#pragma GCC optimize ("O2") | |
#define LOCAL | |
//#include "testlib.h" | |
#include <functional> | |
#include <algorithm> | |
#include <iostream> | |
#include <fstream> | |
#include <sstream> | |
#include <iomanip> | |
#include <numeric> | |
#include <cstring> | |
#include <climits> | |
#include <cassert> | |
#include <complex> | |
#include <cstdio> | |
#include <string> | |
#include <vector> | |
#include <bitset> | |
#include <queue> | |
#include <stack> | |
#include <cmath> | |
#include <ctime> | |
#include <list> | |
#include <set> | |
#include <map> | |
//#include <tr1/unordered_set> | |
//#include <tr1/unordered_map> | |
//#include <array> | |
using namespace std; | |
#define REP(i, n) for (int i=0;i<n;++i) | |
#define FOR(i, a, b) for (int i=a;i<b;++i) | |
#define DWN(i, b, a) for (int i=b-1;i>=a;--i) | |
#define REP_1(i, n) for (int i=1;i<=n;++i) | |
#define FOR_1(i, a, b) for (int i=a;i<=b;++i) | |
#define DWN_1(i, b, a) for (int i=b;i>=a;--i) | |
#define REP_C(i, n) for (int n____=n,i=0;i<n____;++i) | |
#define FOR_C(i, a, b) for (int b____=b,i=a;i<b____;++i) | |
#define DWN_C(i, b, a) for (int a____=a,i=b-1;i>=a____;--i) | |
#define REP_N(i, n) for (i=0;i<n;++i) | |
#define FOR_N(i, a, b) for (i=a;i<b;++i) | |
#define DWN_N(i, b, a) for (i=b-1;i>=a;--i) | |
#define REP_1_C(i, n) for (int n____=n,i=1;i<=n____;++i) | |
#define FOR_1_C(i, a, b) for (int b____=b,i=a;i<=b____;++i) | |
#define DWN_1_C(i, b, a) for (int a____=a,i=b;i>=a____;--i) | |
#define REP_1_N(i, n) for (i=1;i<=n;++i) | |
#define FOR_1_N(i, a, b) for (i=a;i<=b;++i) | |
#define DWN_1_N(i, b, a) for (i=b;i>=a;--i) | |
#define REP_C_N(i, n) for (int n____=(i=0,n);i<n____;++i) | |
#define FOR_C_N(i, a, b) for (int b____=(i=0,b);i<b____;++i) | |
#define DWN_C_N(i, b, a) for (int a____=(i=b-1,a);i>=a____;--i) | |
#define REP_1_C_N(i, n) for (int n____=(i=1,n);i<=n____;++i) | |
#define FOR_1_C_N(i, a, b) for (int b____=(i=a,b);i<=b____;++i) | |
#define DWN_1_C_N(i, b, a) for (int a____=(i=b,a);i>=a____;--i) | |
#define ECH(it, A) for (__typeof(A.begin()) it=A.begin(); it != A.end(); ++it) | |
#define REP_S(i, str) for (char*i=str;*i;++i) | |
#define REP_L(i, hd, suc) for (int i=hd;i;i=suc[i]) | |
#define REP_G(i, u) REP_L(i,hd[u],suc) | |
#define REP_SS(x, s) for (int x=s;x;x=(x-1)&s) | |
#define DO(n) for ( int ____n = n; ____n-->0; ) | |
#define REP_2(i, j, n, m) REP(i, n) REP(j, m) | |
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m) | |
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l) | |
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l) | |
#define REP_4(i, j, k, ii, n, m, l, nn) REP(i, n) REP(j, m) REP(k, l) REP(ii, nn) | |
#define REP_4_1(i, j, k, ii, n, m, l, nn) REP_1(i, n) REP_1(j, m) REP_1(k, l) REP_1(ii, nn) | |
#define ALL(A) A.begin(), A.end() | |
#define LLA(A) A.rbegin(), A.rend() | |
#define CPY(A, B) memcpy(A, B, sizeof(A)) | |
#define INS(A, P, B) A.insert(A.begin() + P, B) | |
#define ERS(A, P) A.erase(A.begin() + P) | |
#define LBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define UBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define CTN(T, x) (T.find(x) != T.end()) | |
#define SZ(A) int((A).size()) | |
#define PB push_back | |
#define MP(A, B) make_pair(A, B) | |
#define PTT pair<T, T> | |
#define Ts *this | |
#define rTs return Ts | |
#define fi first | |
#define se second | |
#define re real() | |
#define im imag() | |
#define Rush for(int ____T=RD(); ____T--;) | |
#define Display(A, n, m) { \ | |
REP(i, n){ \ | |
REP(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m-1] << endl; \ | |
} \ | |
} | |
#define Display_1(A, n, m) { \ | |
REP_1(i, n){ \ | |
REP_1(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m] << endl; \ | |
} \ | |
} | |
typedef long long LL; | |
//typedef long double DB; | |
typedef double DB; | |
typedef unsigned uint; | |
typedef unsigned long long uLL; | |
typedef vector<int> VI; | |
typedef vector<char> VC; | |
typedef vector<string> VS; | |
typedef vector<LL> VL; | |
typedef vector<DB> VF; | |
typedef set<int> SI; | |
typedef set<string> SS; | |
typedef map<int, int> MII; | |
typedef map<string, int> MSI; | |
typedef pair<int, int> PII; | |
typedef pair<LL, LL> PLL; | |
typedef vector<PII> VII; | |
typedef vector<VI> VVI; | |
typedef vector<VII> VVII; | |
template<class T> inline T& RD(T &); | |
template<class T> inline void OT(const T &); | |
//inline int RD(){int x; return RD(x);} | |
inline LL RD(){LL x; return RD(x);} | |
inline DB& RF(DB &); | |
inline DB RF(){DB x; return RF(x);} | |
inline char* RS(char *s); | |
inline char& RC(char &c); | |
inline char RC(); | |
inline char& RC(char &c){scanf(" %c", &c); return c;} | |
inline char RC(){char c; return RC(c);} | |
//inline char& RC(char &c){c = getchar(); return c;} | |
//inline char RC(){return getchar();} | |
template<class T> inline T& RDD(T &); | |
inline LL RDD(){LL x; return RDD(x);} | |
template<class T0, class T1> inline T0& RD(T0 &x0, T1 &x1){RD(x0), RD(x1); return x0;} | |
template<class T0, class T1, class T2> inline T0& RD(T0 &x0, T1 &x1, T2 &x2){RD(x0), RD(x1), RD(x2); return x0;} | |
template<class T0, class T1, class T2, class T3> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3){RD(x0), RD(x1), RD(x2), RD(x3); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); return x0;} | |
template<class T0, class T1> inline void OT(const T0 &x0, const T1 &x1){OT(x0), OT(x1);} | |
template<class T0, class T1, class T2> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2){OT(x0), OT(x1), OT(x2);} | |
template<class T0, class T1, class T2, class T3> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3){OT(x0), OT(x1), OT(x2), OT(x3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5, const T6 &x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);} | |
inline char& RC(char &a, char &b){RC(a), RC(b); return a;} | |
inline char& RC(char &a, char &b, char &c){RC(a), RC(b), RC(c); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d){RC(a), RC(b), RC(c), RC(d); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e){RC(a), RC(b), RC(c), RC(d), RC(e); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g); return a;} | |
inline DB& RF(DB &a, DB &b){RF(a), RF(b); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c){RF(a), RF(b), RF(c); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d){RF(a), RF(b), RF(c), RF(d); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e){RF(a), RF(b), RF(c), RF(d), RF(e); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f, DB &g){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g); return a;} | |
inline void RS(char *s1, char *s2){RS(s1), RS(s2);} | |
inline void RS(char *s1, char *s2, char *s3){RS(s1), RS(s2), RS(s3);} | |
template<class T0,class T1>inline void RDD(T0&a, T1&b){RDD(a),RDD(b);} | |
template<class T0,class T1,class T2>inline void RDD(T0&a, T1&b, T2&c){RDD(a),RDD(b),RDD(c);} | |
template<class T> inline void RST(T &A){memset(A, 0, sizeof(A));} | |
template<class T> inline void FLC(T &A, int x){memset(A, x, sizeof(A));} | |
template<class T> inline void CLR(T &A){A.clear();} | |
template<class T0, class T1> inline void RST(T0 &A0, T1 &A1){RST(A0), RST(A1);} | |
template<class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2){RST(A0), RST(A1), RST(A2);} | |
template<class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3){RST(A0), RST(A1), RST(A2), RST(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);} | |
template<class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x){FLC(A0, x), FLC(A1, x);} | |
template<class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x);} | |
template<class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x), FLC(A6, x);} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, less<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(stack<T> &S){while (!S.empty()) S.pop();} | |
template<class T0, class T1> inline void CLR(T0 &A0, T1 &A1){CLR(A0), CLR(A1);} | |
template<class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2){CLR(A0), CLR(A1), CLR(A2);} | |
template<class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);} | |
template<class T> inline void CLR(T &A, int n){REP(i, n) CLR(A[i]);} | |
template<class T> inline bool EPT(T &a){return a.empty();} | |
template<class T> inline T& SRT(T &A){sort(ALL(A)); return A;} | |
template<class T, class C> inline T& SRT(T &A, C B){sort(ALL(A), B); return A;} | |
template<class T> inline T& RVS(T &A){reverse(ALL(A)); return A;} | |
template<class T> inline T& UNQQ(T &A){A.resize(unique(ALL(A))-A.begin());return A;} | |
template<class T> inline T& UNQ(T &A){SRT(A);return UNQQ(A);} | |
//} | |
/** Constant List .. **/ //{ | |
const int MOD = int(1e9) + 7; | |
const int INF = 0x3f3f3f3f; | |
const LL INFF = 0x3f3f3f3f3f3f3f3fLL; | |
const DB EPS = 1e-9; | |
const DB OO = 1e20; | |
const DB PI = acos(-1.0); //M_PI; | |
const int dx[] = {-1, 0, 1, 0}; | |
const int dy[] = {0, 1, 0, -1}; | |
//} | |
/** Add On .. **/ //{ | |
// <<= '0. Nichi Joo ., //{ | |
template<class T> inline T& checkMin(T &a,const T b){if (b<a) a=b;return a;} | |
template<class T> inline T& checkMax(T &a,const T b){if (a<b) a=b;return a;} | |
template<class T> inline T& checkMin(T &a, T &b, const T x){checkMin(a, x), checkMin(b, x);return a;} | |
template<class T> inline T& checkMax(T &a, T &b, const T x){checkMax(a, x), checkMax(b, x);return a;} | |
template <class T, class C> inline T& checkMin(T& a, const T b, C c){if (c(b,a)) a = b;return a;} | |
template <class T, class C> inline T& checkMax(T& a, const T b, C c){if (c(a,b)) a = b;return a;} | |
template<class T> inline T min(T a, T b, T c){return min(min(a, b), c);} | |
template<class T> inline T max(T a, T b, T c){return max(max(a, b), c);} | |
template<class T> inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));} | |
template<class T> inline T max(T a, T b, T c, T d){return max(max(a, b), max(c, d));} | |
template<class T> inline T min(T a, T b, T c, T d, T e){return min(min(min(a,b),min(c,d)),e);} | |
template<class T> inline T max(T a, T b, T c, T d, T e){return max(max(max(a,b),max(c,d)),e);} | |
template<class T> inline T sqr(T a){return a*a;} | |
template<class T> inline T cub(T a){return a*a*a;} | |
template<class T> inline T ceil(T x, T y){return (x - 1) / y + 1;} | |
template<class T> T abs(T x){return x>0?x:-x;} | |
inline int sgn(DB x){return x < -EPS ? -1 : x > EPS;} | |
inline int sgn(DB x, DB y){return sgn(x - y);} | |
inline DB cos(DB a, DB b, DB c){return (sqr(a)+sqr(b)-sqr(c))/(2*a*b);} | |
inline DB cot(DB x){return 1./tan(x);}; | |
inline DB sec(DB x){return 1./cos(x);}; | |
inline DB csc(DB x){return 1./sin(x);}; | |
//} | |
// <<= '1. Bitwise Operation ., //{ | |
namespace BO{ | |
inline bool _1(int x, int i){return bool(x&1<<i);} | |
inline bool _1(LL x, int i){return bool(x&1LL<<i);} | |
inline LL _1(int i){return 1LL<<i;} | |
inline LL _U(int i){return _1(i) - 1;}; | |
inline int reverse_bits(int x){ | |
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa); | |
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc); | |
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0); | |
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00); | |
x = ((x >>16) & 0x0000ffff) | ((x <<16) & 0xffff0000); | |
return x; | |
} | |
inline LL reverse_bits(LL x){ | |
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL); | |
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL); | |
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL); | |
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL); | |
x = ((x >>16) & 0x0000ffff0000ffffLL) | ((x <<16) & 0xffff0000ffff0000LL); | |
x = ((x >>32) & 0x00000000ffffffffLL) | ((x <<32) & 0xffffffff00000000LL); | |
return x; | |
} | |
template<class T> inline bool odd(T x){return x&1;} | |
template<class T> inline bool even(T x){return !odd(x);} | |
template<class T> inline T low_bit(T x) {return x & -x;} | |
template<class T> inline T high_bit(T x) {T p = low_bit(x);while (p != x) x -= p, p = low_bit(x);return p;} | |
template<class T> inline T cover_bit(T x){T p = 1; while (p < x) p <<= 1;return p;} | |
template<class T> inline int cover_idx(T x){int p = 0; while (_1(p) < x ) ++p; return p;} | |
inline int clz(int x){return __builtin_clz(x);} | |
inline int clz(LL x){return __builtin_clzll(x);} | |
inline int ctz(int x){return __builtin_ctz(x);} | |
inline int ctz(LL x){return __builtin_ctzll(x);} | |
inline int lg2(int x){return !x ? -1 : 31 - clz(x);} | |
inline int lg2(LL x){return !x ? -1 : 63 - clz(x);} | |
inline int low_idx(int x){return !x ? -1 : ctz(x);} | |
inline int low_idx(LL x){return !x ? -1 : ctz(x);} | |
inline int high_idx(int x){return lg2(x);} | |
inline int high_idx(LL x){return lg2(x);} | |
inline int parity(int x){return __builtin_parity(x);} | |
inline int parity(LL x){return __builtin_parityll(x);} | |
inline int count_bits(int x){return __builtin_popcount(x);} | |
inline int count_bits(LL x){return __builtin_popcountll(x);} | |
} using namespace BO;//} | |
//} | |
/** I/O Accelerator Interface .. **/ //{ | |
#define g (c=getchar()) | |
#define d isdigit(g) | |
#define p x=x*10+c-'0' | |
#define n x=x*10+'0'-c | |
#define pp l/=10,p | |
#define nn l/=10,n | |
template<class T> inline T& RD(T &x){ | |
char c;while(!d);x=c-'0';while(d)p; | |
return x; | |
} | |
template<class T> inline T& RDD(T &x){ | |
char c;while(g,c!='-'&&!isdigit(c)); | |
if (c=='-'){x='0'-g;while(d)n;} | |
else{x=c-'0';while(d)p;} | |
return x; | |
} | |
inline DB& RF(DB &x){ | |
//scanf("%lf", &x); | |
char c;while(g,c!='-'&&c!='.'&&!isdigit(c)); | |
if(c=='-')if(g=='.'){x=0;DB l=1;while(d)nn;x*=l;} | |
else{x='0'-c;while(d)n;if(c=='.'){DB l=1;while(d)nn;x*=l;}} | |
else if(c=='.'){x=0;DB l=1;while(d)pp;x*=l;} | |
else{x=c-'0';while(d)p;if(c=='.'){DB l=1;while(d)pp;x*=l;}} | |
return x; | |
} | |
#undef nn | |
#undef pp | |
#undef n | |
#undef p | |
#undef d | |
#undef g | |
inline char* RS(char *s){ | |
//gets(s); | |
scanf("%s", s); | |
return s; | |
} | |
LL last_ans; int Case; template<class T> inline void OT(const T &x){ | |
//printf("Case #%d: ", ++Case); | |
//printf("%lld\n", x); | |
//printf("%.9f\n", x); | |
printf("%d\n", x); | |
//cout << x << endl; | |
//last_ans = x; | |
} | |
//} | |
//}/* .................................................................................................................................. */ | |
const int N = int(1e3) + 9; | |
struct base_phi_number{ | |
int A[2*N], *a; | |
int lo, hi; | |
void out(){ | |
DWN_1(i, hi, 0) printf("%d", a[i]); if (lo < 0) putchar('.'); | |
DWN(i, 0, lo) printf("%d", a[i]); | |
puts(""); | |
} | |
void init(int n){ | |
RST(A); a=A+N; lo = 0, hi = 0, a[0] = n; | |
bool upd; do{ | |
upd = 0; DWN_1(i, hi, lo) if (a[i] >= 2){ | |
a[i+1] += a[i]/2; | |
a[i-2] += a[i]/2; | |
a[i] %= 2, upd = 1; | |
} | |
DWN_1(i, hi, lo) if (a[i] && a[i-1]){ | |
int d = min(a[i], a[i-1]); | |
a[i+1] += d, a[i] -= d, a[i-1] -= d; | |
upd = 1; | |
} | |
while (a[hi+1]) ++hi; | |
while (a[lo-1] || a[lo-2]) --lo; | |
while (!a[lo]) ++lo; | |
} while(upd); | |
} | |
} A; | |
int main(){ | |
#ifndef ONLINE_JUDGE | |
freopen("in.txt", "r", stdin); | |
//freopen("out.txt", "w", stdout); | |
#endif | |
int n; while (~scanf("%d", &n)){ | |
A.init(n); | |
A.out(); | |
} | |
} | |
/* | |
11 | |
100 | |
200 | |
1001 | |
*/ | |
/* | |
101010101 | |
1001 | |
1001 | |
1001 | |
1001 | |
1011111101 | |
*/ |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** Micro Mezz Macro Flation -- Overheated Economy ., Last Update: May. 7th 2014 **/ //{ | |
/** Header .. **/ //{ | |
#pragma comment(linker, "/STACK:36777216") | |
//#pragma GCC optimize ("O2") | |
#define LOCAL | |
//#include "testlib.h" | |
#include <functional> | |
#include <algorithm> | |
#include <iostream> | |
#include <fstream> | |
#include <sstream> | |
#include <iomanip> | |
#include <numeric> | |
#include <cstring> | |
#include <climits> | |
#include <cassert> | |
#include <complex> | |
#include <cstdio> | |
#include <string> | |
#include <vector> | |
#include <bitset> | |
#include <queue> | |
#include <stack> | |
#include <cmath> | |
#include <ctime> | |
#include <list> | |
#include <set> | |
#include <map> | |
//#include <tr1/unordered_set> | |
//#include <tr1/unordered_map> | |
//#include <array> | |
using namespace std; | |
#define REP(i, n) for (int i=0;i<n;++i) | |
#define FOR(i, a, b) for (int i=a;i<b;++i) | |
#define DWN(i, b, a) for (int i=b-1;i>=a;--i) | |
#define REP_1(i, n) for (int i=1;i<=n;++i) | |
#define FOR_1(i, a, b) for (int i=a;i<=b;++i) | |
#define DWN_1(i, b, a) for (int i=b;i>=a;--i) | |
#define REP_C(i, n) for (int n____=n,i=0;i<n____;++i) | |
#define FOR_C(i, a, b) for (int b____=b,i=a;i<b____;++i) | |
#define DWN_C(i, b, a) for (int a____=a,i=b-1;i>=a____;--i) | |
#define REP_N(i, n) for (i=0;i<n;++i) | |
#define FOR_N(i, a, b) for (i=a;i<b;++i) | |
#define DWN_N(i, b, a) for (i=b-1;i>=a;--i) | |
#define REP_1_C(i, n) for (int n____=n,i=1;i<=n____;++i) | |
#define FOR_1_C(i, a, b) for (int b____=b,i=a;i<=b____;++i) | |
#define DWN_1_C(i, b, a) for (int a____=a,i=b;i>=a____;--i) | |
#define REP_1_N(i, n) for (i=1;i<=n;++i) | |
#define FOR_1_N(i, a, b) for (i=a;i<=b;++i) | |
#define DWN_1_N(i, b, a) for (i=b;i>=a;--i) | |
#define REP_C_N(i, n) for (int n____=(i=0,n);i<n____;++i) | |
#define FOR_C_N(i, a, b) for (int b____=(i=0,b);i<b____;++i) | |
#define DWN_C_N(i, b, a) for (int a____=(i=b-1,a);i>=a____;--i) | |
#define REP_1_C_N(i, n) for (int n____=(i=1,n);i<=n____;++i) | |
#define FOR_1_C_N(i, a, b) for (int b____=(i=a,b);i<=b____;++i) | |
#define DWN_1_C_N(i, b, a) for (int a____=(i=b,a);i>=a____;--i) | |
#define ECH(it, A) for (__typeof(A.begin()) it=A.begin(); it != A.end(); ++it) | |
#define REP_S(i, str) for (char*i=str;*i;++i) | |
#define REP_L(i, hd, suc) for (int i=hd;i;i=suc[i]) | |
#define REP_G(i, u) REP_L(i,hd[u],suc) | |
#define REP_SS(x, s) for (int x=s;x;x=(x-1)&s) | |
#define DO(n) for ( int ____n = n; ____n-->0; ) | |
#define REP_2(i, j, n, m) REP(i, n) REP(j, m) | |
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m) | |
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l) | |
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l) | |
#define REP_4(i, j, k, ii, n, m, l, nn) REP(i, n) REP(j, m) REP(k, l) REP(ii, nn) | |
#define REP_4_1(i, j, k, ii, n, m, l, nn) REP_1(i, n) REP_1(j, m) REP_1(k, l) REP_1(ii, nn) | |
#define ALL(A) A.begin(), A.end() | |
#define LLA(A) A.rbegin(), A.rend() | |
#define CPY(A, B) memcpy(A, B, sizeof(A)) | |
#define INS(A, P, B) A.insert(A.begin() + P, B) | |
#define ERS(A, P) A.erase(A.begin() + P) | |
#define LBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define UBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define CTN(T, x) (T.find(x) != T.end()) | |
#define SZ(A) int((A).size()) | |
#define PB push_back | |
#define MP(A, B) make_pair(A, B) | |
#define PTT pair<T, T> | |
#define Ts *this | |
#define rTs return Ts | |
#define fi first | |
#define se second | |
#define re real() | |
#define im imag() | |
#define Rush for(int ____T=RD(); ____T--;) | |
#define Display(A, n, m) { \ | |
REP(i, n){ \ | |
REP(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m-1] << endl; \ | |
} \ | |
} | |
#define Display_1(A, n, m) { \ | |
REP_1(i, n){ \ | |
REP_1(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m] << endl; \ | |
} \ | |
} | |
typedef long long LL; | |
//typedef long double DB; | |
typedef double DB; | |
typedef unsigned uint; | |
typedef unsigned long long uLL; | |
typedef vector<int> VI; | |
typedef vector<char> VC; | |
typedef vector<string> VS; | |
typedef vector<LL> VL; | |
typedef vector<DB> VF; | |
typedef set<int> SI; | |
typedef set<string> SS; | |
typedef map<int, int> MII; | |
typedef map<string, int> MSI; | |
typedef pair<int, int> PII; | |
typedef pair<LL, LL> PLL; | |
typedef vector<PII> VII; | |
typedef vector<VI> VVI; | |
typedef vector<VII> VVII; | |
template<class T> inline T& RD(T &); | |
template<class T> inline void OT(const T &); | |
//inline int RD(){int x; return RD(x);} | |
inline LL RD(){LL x; return RD(x);} | |
inline DB& RF(DB &); | |
inline DB RF(){DB x; return RF(x);} | |
inline char* RS(char *s); | |
inline char& RC(char &c); | |
inline char RC(); | |
inline char& RC(char &c){scanf(" %c", &c); return c;} | |
inline char RC(){char c; return RC(c);} | |
//inline char& RC(char &c){c = getchar(); return c;} | |
//inline char RC(){return getchar();} | |
template<class T> inline T& RDD(T &); | |
inline LL RDD(){LL x; return RDD(x);} | |
template<class T0, class T1> inline T0& RD(T0 &x0, T1 &x1){RD(x0), RD(x1); return x0;} | |
template<class T0, class T1, class T2> inline T0& RD(T0 &x0, T1 &x1, T2 &x2){RD(x0), RD(x1), RD(x2); return x0;} | |
template<class T0, class T1, class T2, class T3> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3){RD(x0), RD(x1), RD(x2), RD(x3); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); return x0;} | |
template<class T0, class T1> inline void OT(const T0 &x0, const T1 &x1){OT(x0), OT(x1);} | |
template<class T0, class T1, class T2> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2){OT(x0), OT(x1), OT(x2);} | |
template<class T0, class T1, class T2, class T3> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3){OT(x0), OT(x1), OT(x2), OT(x3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5, const T6 &x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);} | |
inline char& RC(char &a, char &b){RC(a), RC(b); return a;} | |
inline char& RC(char &a, char &b, char &c){RC(a), RC(b), RC(c); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d){RC(a), RC(b), RC(c), RC(d); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e){RC(a), RC(b), RC(c), RC(d), RC(e); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g); return a;} | |
inline DB& RF(DB &a, DB &b){RF(a), RF(b); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c){RF(a), RF(b), RF(c); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d){RF(a), RF(b), RF(c), RF(d); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e){RF(a), RF(b), RF(c), RF(d), RF(e); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f, DB &g){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g); return a;} | |
inline void RS(char *s1, char *s2){RS(s1), RS(s2);} | |
inline void RS(char *s1, char *s2, char *s3){RS(s1), RS(s2), RS(s3);} | |
template<class T0,class T1>inline void RDD(T0&a, T1&b){RDD(a),RDD(b);} | |
template<class T0,class T1,class T2>inline void RDD(T0&a, T1&b, T2&c){RDD(a),RDD(b),RDD(c);} | |
template<class T> inline void RST(T &A){memset(A, 0, sizeof(A));} | |
template<class T> inline void FLC(T &A, int x){memset(A, x, sizeof(A));} | |
template<class T> inline void CLR(T &A){A.clear();} | |
template<class T0, class T1> inline void RST(T0 &A0, T1 &A1){RST(A0), RST(A1);} | |
template<class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2){RST(A0), RST(A1), RST(A2);} | |
template<class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3){RST(A0), RST(A1), RST(A2), RST(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);} | |
template<class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x){FLC(A0, x), FLC(A1, x);} | |
template<class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x);} | |
template<class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x), FLC(A6, x);} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, less<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(stack<T> &S){while (!S.empty()) S.pop();} | |
template<class T0, class T1> inline void CLR(T0 &A0, T1 &A1){CLR(A0), CLR(A1);} | |
template<class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2){CLR(A0), CLR(A1), CLR(A2);} | |
template<class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);} | |
template<class T> inline void CLR(T &A, int n){REP(i, n) CLR(A[i]);} | |
template<class T> inline bool EPT(T &a){return a.empty();} | |
template<class T> inline T& SRT(T &A){sort(ALL(A)); return A;} | |
template<class T, class C> inline T& SRT(T &A, C B){sort(ALL(A), B); return A;} | |
template<class T> inline T& RVS(T &A){reverse(ALL(A)); return A;} | |
template<class T> inline T& UNQQ(T &A){A.resize(unique(ALL(A))-A.begin());return A;} | |
template<class T> inline T& UNQ(T &A){SRT(A);return UNQQ(A);} | |
//} | |
/** Constant List .. **/ //{ | |
const int MOD = int(1e9) + 7; | |
const int INF = 0x3f3f3f3f; | |
const LL INFF = 0x3f3f3f3f3f3f3f3fLL; | |
const DB EPS = 1e-9; | |
const DB OO = 1e20; | |
const DB PI = acos(-1.0); //M_PI; | |
const int dx[] = {-1, 0, 1, 0}; | |
const int dy[] = {0, 1, 0, -1}; | |
//} | |
/** Add On .. **/ //{ | |
// <<= '0. Nichi Joo ., //{ | |
template<class T> inline T& checkMin(T &a,const T b){if (b<a) a=b;return a;} | |
template<class T> inline T& checkMax(T &a,const T b){if (a<b) a=b;return a;} | |
template<class T> inline T& checkMin(T &a, T &b, const T x){checkMin(a, x), checkMin(b, x);return a;} | |
template<class T> inline T& checkMax(T &a, T &b, const T x){checkMax(a, x), checkMax(b, x);return a;} | |
template <class T, class C> inline T& checkMin(T& a, const T b, C c){if (c(b,a)) a = b;return a;} | |
template <class T, class C> inline T& checkMax(T& a, const T b, C c){if (c(a,b)) a = b;return a;} | |
template<class T> inline T min(T a, T b, T c){return min(min(a, b), c);} | |
template<class T> inline T max(T a, T b, T c){return max(max(a, b), c);} | |
template<class T> inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));} | |
template<class T> inline T max(T a, T b, T c, T d){return max(max(a, b), max(c, d));} | |
template<class T> inline T min(T a, T b, T c, T d, T e){return min(min(min(a,b),min(c,d)),e);} | |
template<class T> inline T max(T a, T b, T c, T d, T e){return max(max(max(a,b),max(c,d)),e);} | |
template<class T> inline T sqr(T a){return a*a;} | |
template<class T> inline T cub(T a){return a*a*a;} | |
template<class T> inline T ceil(T x, T y){return (x - 1) / y + 1;} | |
template<class T> T abs(T x){return x>0?x:-x;} | |
inline int sgn(DB x){return x < -EPS ? -1 : x > EPS;} | |
inline int sgn(DB x, DB y){return sgn(x - y);} | |
inline DB cos(DB a, DB b, DB c){return (sqr(a)+sqr(b)-sqr(c))/(2*a*b);} | |
inline DB cot(DB x){return 1./tan(x);}; | |
inline DB sec(DB x){return 1./cos(x);}; | |
inline DB csc(DB x){return 1./sin(x);}; | |
//} | |
// <<= '1. Bitwise Operation ., //{ | |
namespace BO{ | |
inline bool _1(int x, int i){return bool(x&1<<i);} | |
inline bool _1(LL x, int i){return bool(x&1LL<<i);} | |
inline LL _1(int i){return 1LL<<i;} | |
inline LL _U(int i){return _1(i) - 1;}; | |
inline int reverse_bits(int x){ | |
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa); | |
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc); | |
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0); | |
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00); | |
x = ((x >>16) & 0x0000ffff) | ((x <<16) & 0xffff0000); | |
return x; | |
} | |
inline LL reverse_bits(LL x){ | |
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL); | |
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL); | |
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL); | |
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL); | |
x = ((x >>16) & 0x0000ffff0000ffffLL) | ((x <<16) & 0xffff0000ffff0000LL); | |
x = ((x >>32) & 0x00000000ffffffffLL) | ((x <<32) & 0xffffffff00000000LL); | |
return x; | |
} | |
template<class T> inline bool odd(T x){return x&1;} | |
template<class T> inline bool even(T x){return !odd(x);} | |
template<class T> inline T low_bit(T x) {return x & -x;} | |
template<class T> inline T high_bit(T x) {T p = low_bit(x);while (p != x) x -= p, p = low_bit(x);return p;} | |
template<class T> inline T cover_bit(T x){T p = 1; while (p < x) p <<= 1;return p;} | |
template<class T> inline int cover_idx(T x){int p = 0; while (_1(p) < x ) ++p; return p;} | |
inline int clz(int x){return __builtin_clz(x);} | |
inline int clz(LL x){return __builtin_clzll(x);} | |
inline int ctz(int x){return __builtin_ctz(x);} | |
inline int ctz(LL x){return __builtin_ctzll(x);} | |
inline int lg2(int x){return !x ? -1 : 31 - clz(x);} | |
inline int lg2(LL x){return !x ? -1 : 63 - clz(x);} | |
inline int low_idx(int x){return !x ? -1 : ctz(x);} | |
inline int low_idx(LL x){return !x ? -1 : ctz(x);} | |
inline int high_idx(int x){return lg2(x);} | |
inline int high_idx(LL x){return lg2(x);} | |
inline int parity(int x){return __builtin_parity(x);} | |
inline int parity(LL x){return __builtin_parityll(x);} | |
inline int count_bits(int x){return __builtin_popcount(x);} | |
inline int count_bits(LL x){return __builtin_popcountll(x);} | |
} using namespace BO;//} | |
// <<= '2. Number Theory .,//{ | |
namespace NT{ | |
inline LL gcd(LL a, LL b){return __gcd(a, b);} | |
inline LL lcm(LL a, LL b){return a*b/gcd(a,b);} | |
inline void INC(int &a, int b){a += b; if (a >= MOD) a -= MOD;} | |
inline int sum(int a, int b){a += b; if (a >= MOD) a -= MOD; return a;} | |
inline void DEC(int &a, int b){a -= b; if (a < 0) a += MOD;} | |
inline int dff(int a, int b){a -= b; if (a < 0) a += MOD; return a;} | |
inline void MUL(int &a, int b){a = (LL)a * b % MOD;} | |
inline int pdt(int a, int b){return (LL)a * b % MOD;} | |
inline int gcd(int m, int n, int &x, int &y){ | |
x = 1, y = 0; int xx = 0, yy = 1, q; | |
while (1){ | |
q = m / n, m %= n; | |
if (!m){x = xx, y = yy; return n;} | |
DEC(x, pdt(q, xx)), DEC(y, pdt(q, yy)); | |
q = n / m, n %= m; | |
if (!n) return m; | |
DEC(xx, pdt(q, x)), DEC(yy, pdt(q, y)); | |
} | |
} | |
inline int sum(int a, int b, int c){return sum(a, sum(b, c));} | |
inline int sum(int a, int b, int c, int d){return sum(sum(a, b), sum(c, d));} | |
inline int pdt(int a, int b, int c){return pdt(a, pdt(b, c));} | |
inline int pdt(int a, int b, int c, int d){return pdt(pdt(a, b), pdt(c, d));} | |
inline int pow(int a, LL b){ | |
int c(1); while (b){ | |
if (b&1) MUL(c, a); | |
MUL(a, a), b >>= 1; | |
} | |
return c; | |
} | |
template<class T> inline T pow(T a, LL b){ | |
T c(1); while (b){ | |
if (b&1) c *= a; | |
a *= a, b >>= 1; | |
} | |
return c; | |
} | |
template<class T> inline T pow(T a, int b){ | |
return pow(a, (LL)b); | |
} | |
inline int _I(int b){ | |
int a = MOD, x1 = 0, x2 = 1, q; | |
while (true){ | |
q = a / b, a %= b; | |
if (!a) return (x2 + MOD) % MOD; | |
DEC(x1, pdt(q, x2)); | |
q = b / a, b %= a; | |
if (!b) return (x1 + MOD) % MOD; | |
DEC(x2, pdt(q, x1)); | |
} | |
} | |
inline void DIV(int &a, int b){MUL(a, _I(b));} | |
inline int qtt(int a, int b){return pdt(a, _I(b));} | |
struct Int{ | |
int val; | |
operator int() const{return val;} | |
Int(int val = 0):val(val){ | |
val %= MOD; if (val < 0) val += MOD; | |
} | |
Int(LL _val){ | |
_val %= MOD; if (_val < 0) _val += MOD; | |
val = _val; | |
} | |
Int& operator +=(const int& rhs){ | |
INC(val, rhs); | |
return *this; | |
} | |
Int operator +(const int& rhs) const{ | |
return sum(val, rhs); | |
} | |
Int& operator -=(const int& rhs){ | |
DEC(val, rhs); | |
return *this; | |
} | |
Int operator -(const int& rhs) const{ | |
return dff(val, rhs); | |
} | |
Int& operator *=(const int& rhs){ | |
MUL(val, rhs); | |
return *this; | |
} | |
Int operator *(const int& rhs) const{ | |
return pdt(val, rhs); | |
} | |
Int& operator /=(const int& rhs){ | |
DIV(val, rhs); | |
return *this; | |
} | |
Int operator /(const int& rhs) const{ | |
return qtt(val, rhs); | |
} | |
Int operator-()const{ | |
return MOD-*this; | |
} | |
}; | |
/* | |
Int Fact[N], Factt[N]; Int Binom(int n, int m){ | |
return Fact[n] * Factt[m] * Factt[n-m]; | |
} | |
*/ | |
/* | |
Fact[0] = 1; REP_1(i, N-1) Fact[i] = Fact[i-1] * i; | |
Factt[N-1] = _I(Fact[N-1]); DWN(i, N, 1) Factt[i-1] = Factt[i] * i; | |
*/ | |
/* | |
int Binom[N][N]; | |
REP(i, N){Binom[i][0] = 1; REP_1(j, i) Binom[i][j] = Binom[i-1][j-1] + Binom[i-1][j];} | |
*/ | |
/* | |
const int PMAX = 1; | |
VI P; bitset<PMAX> isP; | |
void sieve(){ | |
FOR(i, 2, PMAX){ | |
if (!isP[i]) P.PB(i); | |
for (int j=0;j<SZ(P)&&i*P[j]<PMAX;++j){ | |
isP[i*P[j]]=1; if (!(i%P[j])) break; | |
} | |
} | |
} | |
*/ | |
/* | |
inline int phi(int n){ | |
int res = n; for (int i=2;sqr(i)<=n;++i) if (!(n%i)){ | |
DEC(res, qtt(res, i)); | |
do{n /= i;} while(!(n%i)); | |
} | |
if (n != 1) | |
DEC(res, qtt(res, n)); | |
return res; | |
} | |
*/ | |
/*LL d, x, y; void exGcd(LL a, LL b){ | |
if(!b) x = 1, y = 0, d = a; | |
else{ | |
exGcd(b, a%b); LL t = y; | |
y = x - (a/b)*y, x = t; | |
} | |
}*/ | |
} using namespace NT;//} | |
// <<= '9. Comutational Geometry .,//{ | |
namespace CG{ | |
#define cPo const Po& | |
#define cLine const Line& | |
#define cSeg const Seg& | |
inline DB dist2(DB x,DB y){return sqr(x)+sqr(y);} | |
struct Po{ | |
DB x,y;Po(DB x=0,DB y=0):x(x),y(y){} | |
void in(){RF(x,y);}void out(){printf("(%.2f,%.2f)",x,y);} | |
inline friend istream&operator>>(istream&i,Po&p){return i>>p.x>>p.y;} | |
inline friend ostream&operator<<(ostream&o,Po p){return o<<"("<<p.x<<", "<<p.y<< ")";} | |
Po operator-()const{return Po(-x,-y);} | |
Po&operator+=(cPo p){x+=p.x,y+=p.y;rTs;}Po&operator-=(cPo p){x-=p.x,y-=p.y;rTs;} | |
Po&operator*=(DB k){x*=k,y*=k;rTs;}Po&operator/=(DB k){x/=k,y/=k;rTs;} | |
Po&operator*=(cPo p){rTs=Ts*p;}Po&operator/=(cPo p){rTs=Ts/p;} | |
Po operator+(cPo p)const{return Po(x+p.x,y+p.y);}Po operator-(cPo p)const{return Po(x-p.x,y-p.y);} | |
Po operator*(DB k)const{return Po(x*k,y*k);}Po operator/(DB k)const{return Po(x/k,y/k);} | |
Po operator*(cPo p)const{return Po(x*p.x-y*p.y,y*p.x+x*p.y);}Po operator/(cPo p)const{return Po(x*p.x+y*p.y,y*p.x-x*p.y)/p.len2();} | |
bool operator==(cPo p)const{return!sgn(x,p.x)&&!sgn(y,p.y);};bool operator!=(cPo p)const{return sgn(x,p.x)||sgn(y,p.y);} | |
bool operator<(cPo p)const{return sgn(x,p.x)<0||!sgn(x,p.x)&&sgn(y,p.y)<0;}bool operator<=(cPo p)const{return sgn(x,p.x)<0||!sgn(x,p.x)&&sgn(y,p.y)<=0;} | |
bool operator>(cPo p)const{return!(Ts<=p);}bool operator >=(cPo p)const{return!(Ts<p);} | |
DB len2()const{return dist2(x,y);}DB len()const{return sqrt(len2());}DB arg()const{return atan2(y,x);} | |
Po&_1(){rTs/=len();}Po&conj(){y=-y;rTs;}Po<(){swap(x,y),x=-x;rTs;}Po&rt(){swap(x,y),y=-y;rTs;} | |
Po&rot(DB a,cPo o=Po()){Ts-=o;Ts*=Po(cos(a),sin(a));rTs+=o;} | |
}; | |
inline DB dot(DB x1,DB y1,DB x2,DB y2){return x1*x2+y1*y2;} | |
inline DB dot(cPo a,cPo b){return dot(a.x,a.y,b.x,b.y);} | |
inline DB dot(cPo p0,cPo p1,cPo p2){return dot(p1-p0,p2-p0);} | |
inline DB det(DB x1,DB y1,DB x2,DB y2){return x1*y2-x2*y1;} | |
inline DB det(cPo a,cPo b){return det(a.x,a.y,b.x,b.y);} | |
inline DB det(cPo p0,cPo p1,cPo p2){return det(p1-p0,p2-p0);} | |
inline DB ang(cPo p0,cPo p1){return acos(dot(p0,p1)/p0.len()/p1.len());} | |
inline DB ang(cPo p0,cPo p1,cPo p2){return ang(p1-p0,p2-p0);} | |
inline DB ang(cPo p0,cPo p1,cPo p2,cPo p3){return ang(p1-p0,p3-p2);} | |
inline DB dist2(const Po &a, const Po &b){return dist2(a.x-b.x, a.y-b.y);} | |
template<class T1, class T2> inline int dett(const T1 &x, const T2 &y){return sgn(det(x, y));} | |
template<class T1, class T2, class T3> inline int dett(const T1 &x, const T2 &y, const T3 &z){return sgn(det(x, y, z));} | |
template<class T1, class T2, class T3, class T4> inline int dett(const T1 &x, const T2 &y, const T3 &z, const T4 &w){return sgn(det(x, y, z, w));} | |
template<class T1, class T2> inline int dott(const T1 &x, const T2 &y){return sgn(dot(x, y));} | |
template<class T1, class T2, class T3> inline int dott(const T1 &x, const T2 &y, const T3 &z){return sgn(dot(x, y, z));} | |
template<class T1, class T2, class T3, class T4> inline int dott(const T1 &x, const T2 &y, const T3 &z, const T4 &w){return sgn(dot(x, y, z, w));} | |
template<class T1, class T2> inline DB arg(const T1 &x, const T2 &y){DB a=ang(x,y);return~dett(x,y)?a:2*PI-a;} | |
template<class T1, class T2, class T3> inline DB arg(const T1 &x, const T2 &y, const T3 &z){DB a=ang(x,y,z);return~dett(x,y,z)?a:2*PI-a;} | |
template<class T1, class T2, class T3, class T4> inline DB arg(const T1 &x, const T2 &y, const T3 &z, const T4 &w){DB a=ang(x,y,z,w);return~dett(x,y,z,w)?a:2*PI-a;} | |
template<class T1, class T2> inline DB dist(const T1 &x, const T2 &y){return sqrt(dist2(x, y));} | |
template<class T1, class T2, class T3> inline DB dist(const T1 &x, const T2 &y, const T3 &z){return sqrt(dist2(x, y, z));} | |
inline Po _1(Po p){return p._1();}inline Po conj(Po p){return p.conj();} | |
inline Po lt(Po p){return p.lt();}inline Po rt(Po p){return p.rt();} | |
inline Po rot(Po p,DB a,cPo o=Po()){return p.rot(a,o);} | |
inline Po operator *(DB k,cPo p){return p*k;} | |
inline Po operator /(DB k,cPo p){return conj(p)*k/p.len2();} | |
typedef vector<Po> VP; | |
struct Line{ | |
Po a,b;Line(cPo a=Po(),cPo b=Po()):a(a),b(b){} | |
Line(DB x0,DB y0,DB x1,DB y1):a(Po(x0,y0)),b(Po(x1,y1)){} | |
Line(cLine l):a(l.a),b(l.b){} | |
//Ax+By+C=0 | |
Line(DB A,DB B,DB C){ | |
C=-C;if(!::sgn(A))a=Po(0,C/B),b=Po(1,C/B); | |
else if(!::sgn(B))a=Po(C/A,0),b=Po(C/A,1); | |
else a=Po(0,C/B),b=Po(1,(C-A)/B); | |
} | |
void in(){a.in(),b.in();} | |
inline friend istream&operator>>(istream&i,Line& p){return i>>p.a>>p.b;} | |
inline friend ostream&operator<<(ostream&o,Line p){return o<<p.a<<"-"<< p.b;} | |
Line operator+(cPo x)const{return Line(a+x,b+x);} | |
Line operator-(cPo x)const{return Line(a-x,b-x);} | |
Line operator*(DB k)const{return Line(a*k,b*k);} | |
Line operator/(DB k)const{return Line(a/k,b/k);} | |
Po operator*(cLine)const; | |
Po d()const{return b-a;}DB len2()const{return d().len2();}DB len()const{return d().len();}DB arg()const{return d().arg();} | |
int sgn(cPo p)const{return dett(a, b, p);} | |
int sgn(cLine)const; | |
bool sameSgn(cPo p1,cPo p2)const{return sgn(p1)==sgn(p2);} | |
void getEquation(DB&K,DB&B)const{ | |
K = ::sgn(a.x, b.x) ? (b.y-a.y)/(b.x-a.x) : OO; | |
B = a.y - K*a.x; | |
} | |
void getEquation(DB&A,DB&B,DB&C)const{A=a.y-b.y,B=b.x-a.x,C=det(a, b);} | |
Line&push(DB r){ // 正数右手螺旋向里 | |
Po v=d()._1().lt()*r;a+=v,b+=v; rTs; | |
} | |
}; | |
inline DB dot(cLine l1,cLine l2){return dot(l1.d(),l2.d());} | |
inline DB dot(cLine l,cPo p){return dot(l.a,l.b,p);} | |
inline DB dot(cPo p,cLine l){return dot(p,l.a,l.b);} | |
inline DB det(cLine l1,cLine l2){return det(l1.d(),l2.d());} | |
inline DB det(cLine l,cPo p){return det(l.a,l.b,p);} | |
inline DB det(cPo p,cLine l){return det(p,l.a,l.b);} | |
inline DB ang(cLine l0,cLine l1){return ang(l0.d(),l1.d());} | |
inline DB ang(cLine l,cPo p){return ang(l.a,l.b,p);} | |
inline DB ang(cPo p,cLine l){return ang(p,l.a,l.b);} | |
inline int Line::sgn(cLine l)const{return dett(Ts, l);} | |
inline Po Line::operator*(cLine l)const{return a+d()*det(a,l)/det(Ts,l);} | |
inline Po operator&(cPo p,cLine l){return l*Line(p,p+l.d().lt());} | |
inline Po operator%(cPo p,cLine l){return p&l*2-p;} | |
inline Line push(Line l, DB r){return l.push(r);} | |
struct Seg: public Line{ | |
Seg(cPo a=Po(),cPo b=Po()):Line(a,b){} | |
Seg(DB x0,DB y0,DB x1,DB y1):Line(x0,y0,x1,y1){} | |
Seg(cLine l):Line(l){} | |
Seg(const Po &a,DB alpha):Line(a,alpha){} | |
Seg(DB A,DB B,DB C):Line(A,B,C){} | |
inline int sgn(cPo p)const; | |
inline int sgn(cLine l)const; | |
inline bool qrt(cSeg l)const; | |
inline int sgn(cSeg l)const; | |
}; | |
// -1不相交 0相交(不规范) 1相交(规范) | |
inline int Seg::sgn(cPo p)const{return -dott(p,a,b);} | |
inline int Seg::sgn(cLine l)const{return sgn(Ts*l);} | |
// quick_rejection_test | |
inline bool Seg::qrt(cSeg l)const{ | |
return min(a.x,b.x)<=max(l.a.x,l.b.x)&&min(l.a.x,l.b.x)<=max(a.x,b.x)&& | |
min(a.y,b.y)<=max(l.a.y,l.b.y)&&min(l.a.y,l.b.y)<=max(a.y,b.y); | |
} | |
inline int Seg::sgn(cSeg l)const{ | |
if (!qrt(l)) return -1; | |
/*return | |
(dett(a,b,l.a)*dett(a,b,l.b)<=0 && | |
dett(l.a,l.b,a)*dett(l.a,l.b,b)<=0)?1:-1;*/ | |
int d1=dett(a,b,l.a),d2=dett(a,b,l.b),d3=dett(l.a,l.b,a),d4=dett(l.a,l.b,b); | |
if ((d1^d2)==-2&&(d3^d4)==-2)return 1; | |
return ((!d1&&dott(l.a-a,l.a-b)<=0)||(!d2&&dott(l.b-a,l.b-b)<=0)|| | |
(!d3&&dott(a-l.a,a-l.b)<=0)||(!d4&&dott(b-l.a,b-l.b)<=0))?0:-1; | |
} | |
//inline DB dist2(cLine l,cPo p){return sqr(fabs(dot(lt(l.d()), p-l.a)))/l.len2();} | |
inline DB dist2(cLine l,cPo p){return sqr(fabs(det(l.d(), p-l.a)))/l.len2();} | |
inline DB dist2(cLine l1,cLine l2){return dett(l1,l2)?0:dist2(l1,l2.a);} | |
inline DB dist2(cSeg l,cPo p){ | |
Po pa = p - l.a, pb = p - l.b; | |
if (dott(l.d(), pa) <= 0) return pa.len2(); | |
if (dott(l.d(), pb) >= 0) return pb.len2(); | |
return dist2(Line(l), p); | |
} | |
inline DB dist2(cSeg s,cLine l){ | |
Po v1=s.a-l.a,v2=s.b-l.a;DB d1=det(l.d(),v1),d2=det(l.d(),v2); | |
return sgn(d1)!=sgn(d2) ? 0 : sqr(min(fabs(d1), fabs(d2)))/l.len2(); | |
} | |
inline DB dist2(cSeg l1,cSeg l2){ | |
if (~l1.sgn(l2)) return 0; | |
else return min(dist2(l2,l1.a), dist2(l2,l1.b), dist2(l1,l2.a), dist2(l1,l2.b)); | |
} | |
template<class T1, class T2> inline DB dist2(const T1& a, const T2& b){ | |
return dist2(b, a); | |
} | |
Po getPo(){Po p;p.in();return p;} | |
Line getLine(){Line l;l.in();return l;} | |
DB getArea(const VP& P){DB z=0;FOR(i,1,SZ(P))z+=det(P[i-1],P[i]);return z;} | |
DB getPeri(const VP& P){DB z=0;FOR(i,1,SZ(P))z+=dist(P[i-1],P[i]);return z;} | |
} using namespace CG;//} | |
//} | |
/** I/O Accelerator Interface .. **/ //{ | |
#define g (c=getchar()) | |
#define d isdigit(g) | |
#define p x=x*10+c-'0' | |
#define n x=x*10+'0'-c | |
#define pp l/=10,p | |
#define nn l/=10,n | |
template<class T> inline T& RD(T &x){ | |
char c;while(!d);x=c-'0';while(d)p; | |
return x; | |
} | |
template<class T> inline T& RDD(T &x){ | |
char c;while(g,c!='-'&&!isdigit(c)); | |
if (c=='-'){x='0'-g;while(d)n;} | |
else{x=c-'0';while(d)p;} | |
return x; | |
} | |
inline DB& RF(DB &x){ | |
//scanf("%lf", &x); | |
char c;while(g,c!='-'&&c!='.'&&!isdigit(c)); | |
if(c=='-')if(g=='.'){x=0;DB l=1;while(d)nn;x*=l;} | |
else{x='0'-c;while(d)n;if(c=='.'){DB l=1;while(d)nn;x*=l;}} | |
else if(c=='.'){x=0;DB l=1;while(d)pp;x*=l;} | |
else{x=c-'0';while(d)p;if(c=='.'){DB l=1;while(d)pp;x*=l;}} | |
return x; | |
} | |
#undef nn | |
#undef pp | |
#undef n | |
#undef p | |
#undef d | |
#undef g | |
inline char* RS(char *s){ | |
//gets(s); | |
scanf("%s", s); | |
return s; | |
} | |
LL last_ans; int Case; template<class T> inline void OT(const T &x){ | |
//printf("Case #%d: ", ++Case); | |
//printf("%lld\n", x); | |
//printf("%.3f\n", x); | |
printf("%d\n", x); | |
//cout << x << endl; | |
//last_ans = x; | |
} | |
//} | |
//}/* .................................................................................................................................. */ | |
const int N = 40, M = N*1000+1; | |
DB dp[M]; int n; DB p; | |
int main(){ | |
#ifndef ONLINE_JUDGE | |
freopen("in.txt", "r", stdin); | |
//freopen("out.txt", "w", stdout); | |
#endif | |
Rush{ | |
RST(dp); dp[0] = 1; int m = 0; | |
RD(n); RF(p); REP(i, n){ | |
int a; m += RD(a); DWN_1(i, m, 0) dp[i] = dp[i]/2 + (i-a>=0?dp[i-a]/2:0); | |
} | |
DB s=0; REP(i, M) if (~sgn(s += dp[i], p)){ | |
OT(i); break; | |
} | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** Micro Mezz Macro Flation -- Overheated Economy ., Last Update: May. 7th 2014 **/ //{ | |
/** Header .. **/ //{ | |
#pragma comment(linker, "/STACK:36777216") | |
//#pragma GCC optimize ("O2") | |
#define LOCAL | |
//#include "testlib.h" | |
#include <functional> | |
#include <algorithm> | |
#include <iostream> | |
#include <fstream> | |
#include <sstream> | |
#include <iomanip> | |
#include <numeric> | |
#include <cstring> | |
#include <climits> | |
#include <cassert> | |
#include <complex> | |
#include <cstdio> | |
#include <string> | |
#include <vector> | |
#include <bitset> | |
#include <queue> | |
#include <stack> | |
#include <cmath> | |
#include <ctime> | |
#include <list> | |
#include <set> | |
#include <map> | |
//#include <tr1/unordered_set> | |
//#include <tr1/unordered_map> | |
//#include <array> | |
using namespace std; | |
#define REP(i, n) for (int i=0;i<n;++i) | |
#define FOR(i, a, b) for (int i=a;i<b;++i) | |
#define DWN(i, b, a) for (int i=b-1;i>=a;--i) | |
#define REP_1(i, n) for (int i=1;i<=n;++i) | |
#define FOR_1(i, a, b) for (int i=a;i<=b;++i) | |
#define DWN_1(i, b, a) for (int i=b;i>=a;--i) | |
#define REP_C(i, n) for (int n____=n,i=0;i<n____;++i) | |
#define FOR_C(i, a, b) for (int b____=b,i=a;i<b____;++i) | |
#define DWN_C(i, b, a) for (int a____=a,i=b-1;i>=a____;--i) | |
#define REP_N(i, n) for (i=0;i<n;++i) | |
#define FOR_N(i, a, b) for (i=a;i<b;++i) | |
#define DWN_N(i, b, a) for (i=b-1;i>=a;--i) | |
#define REP_1_C(i, n) for (int n____=n,i=1;i<=n____;++i) | |
#define FOR_1_C(i, a, b) for (int b____=b,i=a;i<=b____;++i) | |
#define DWN_1_C(i, b, a) for (int a____=a,i=b;i>=a____;--i) | |
#define REP_1_N(i, n) for (i=1;i<=n;++i) | |
#define FOR_1_N(i, a, b) for (i=a;i<=b;++i) | |
#define DWN_1_N(i, b, a) for (i=b;i>=a;--i) | |
#define REP_C_N(i, n) for (int n____=(i=0,n);i<n____;++i) | |
#define FOR_C_N(i, a, b) for (int b____=(i=0,b);i<b____;++i) | |
#define DWN_C_N(i, b, a) for (int a____=(i=b-1,a);i>=a____;--i) | |
#define REP_1_C_N(i, n) for (int n____=(i=1,n);i<=n____;++i) | |
#define FOR_1_C_N(i, a, b) for (int b____=(i=a,b);i<=b____;++i) | |
#define DWN_1_C_N(i, b, a) for (int a____=(i=b,a);i>=a____;--i) | |
#define ECH(it, A) for (__typeof(A.begin()) it=A.begin(); it != A.end(); ++it) | |
#define REP_S(i, str) for (char*i=str;*i;++i) | |
#define REP_L(i, hd, suc) for (int i=hd;i;i=suc[i]) | |
#define REP_G(i, u) REP_L(i,hd[u],suc) | |
#define REP_SS(x, s) for (int x=s;x;x=(x-1)&s) | |
#define DO(n) for ( int ____n = n; ____n-->0; ) | |
#define REP_2(i, j, n, m) REP(i, n) REP(j, m) | |
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m) | |
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l) | |
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l) | |
#define REP_4(i, j, k, ii, n, m, l, nn) REP(i, n) REP(j, m) REP(k, l) REP(ii, nn) | |
#define REP_4_1(i, j, k, ii, n, m, l, nn) REP_1(i, n) REP_1(j, m) REP_1(k, l) REP_1(ii, nn) | |
#define ALL(A) A.begin(), A.end() | |
#define LLA(A) A.rbegin(), A.rend() | |
#define CPY(A, B) memcpy(A, B, sizeof(A)) | |
#define INS(A, P, B) A.insert(A.begin() + P, B) | |
#define ERS(A, P) A.erase(A.begin() + P) | |
#define LBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define UBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define CTN(T, x) (T.find(x) != T.end()) | |
#define SZ(A) int((A).size()) | |
#define PB push_back | |
#define MP(A, B) make_pair(A, B) | |
#define PTT pair<T, T> | |
#define Ts *this | |
#define rTs return Ts | |
#define fi first | |
#define se second | |
#define re real() | |
#define im imag() | |
#define Rush for(int ____T=RD(); ____T--;) | |
#define Display(A, n, m) { \ | |
REP(i, n){ \ | |
REP(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m-1] << endl; \ | |
} \ | |
} | |
#define Display_1(A, n, m) { \ | |
REP_1(i, n){ \ | |
REP_1(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m] << endl; \ | |
} \ | |
} | |
typedef long long LL; | |
//typedef long double DB; | |
typedef double DB; | |
typedef unsigned uint; | |
typedef unsigned long long uLL; | |
typedef vector<int> VI; | |
typedef vector<char> VC; | |
typedef vector<string> VS; | |
typedef vector<LL> VL; | |
typedef vector<DB> VF; | |
typedef set<int> SI; | |
typedef set<string> SS; | |
typedef map<int, int> MII; | |
typedef map<string, int> MSI; | |
typedef pair<int, int> PII; | |
typedef pair<LL, LL> PLL; | |
typedef vector<PII> VII; | |
typedef vector<VI> VVI; | |
typedef vector<VII> VVII; | |
template<class T> inline T& RD(T &); | |
template<class T> inline void OT(const T &); | |
//inline int RD(){int x; return RD(x);} | |
inline LL RD(){LL x; return RD(x);} | |
inline DB& RF(DB &); | |
inline DB RF(){DB x; return RF(x);} | |
inline char* RS(char *s); | |
inline char& RC(char &c); | |
inline char RC(); | |
inline char& RC(char &c){scanf(" %c", &c); return c;} | |
inline char RC(){char c; return RC(c);} | |
//inline char& RC(char &c){c = getchar(); return c;} | |
//inline char RC(){return getchar();} | |
template<class T> inline T& RDD(T &); | |
inline LL RDD(){LL x; return RDD(x);} | |
template<class T0, class T1> inline T0& RD(T0 &x0, T1 &x1){RD(x0), RD(x1); return x0;} | |
template<class T0, class T1, class T2> inline T0& RD(T0 &x0, T1 &x1, T2 &x2){RD(x0), RD(x1), RD(x2); return x0;} | |
template<class T0, class T1, class T2, class T3> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3){RD(x0), RD(x1), RD(x2), RD(x3); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); return x0;} | |
template<class T0, class T1> inline void OT(const T0 &x0, const T1 &x1){OT(x0), OT(x1);} | |
template<class T0, class T1, class T2> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2){OT(x0), OT(x1), OT(x2);} | |
template<class T0, class T1, class T2, class T3> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3){OT(x0), OT(x1), OT(x2), OT(x3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5, const T6 &x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);} | |
inline char& RC(char &a, char &b){RC(a), RC(b); return a;} | |
inline char& RC(char &a, char &b, char &c){RC(a), RC(b), RC(c); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d){RC(a), RC(b), RC(c), RC(d); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e){RC(a), RC(b), RC(c), RC(d), RC(e); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g); return a;} | |
inline DB& RF(DB &a, DB &b){RF(a), RF(b); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c){RF(a), RF(b), RF(c); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d){RF(a), RF(b), RF(c), RF(d); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e){RF(a), RF(b), RF(c), RF(d), RF(e); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f, DB &g){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g); return a;} | |
inline void RS(char *s1, char *s2){RS(s1), RS(s2);} | |
inline void RS(char *s1, char *s2, char *s3){RS(s1), RS(s2), RS(s3);} | |
template<class T0,class T1>inline void RDD(T0&a, T1&b){RDD(a),RDD(b);} | |
template<class T0,class T1,class T2>inline void RDD(T0&a, T1&b, T2&c){RDD(a),RDD(b),RDD(c);} | |
template<class T> inline void RST(T &A){memset(A, 0, sizeof(A));} | |
template<class T> inline void FLC(T &A, int x){memset(A, x, sizeof(A));} | |
template<class T> inline void CLR(T &A){A.clear();} | |
template<class T0, class T1> inline void RST(T0 &A0, T1 &A1){RST(A0), RST(A1);} | |
template<class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2){RST(A0), RST(A1), RST(A2);} | |
template<class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3){RST(A0), RST(A1), RST(A2), RST(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);} | |
template<class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x){FLC(A0, x), FLC(A1, x);} | |
template<class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x);} | |
template<class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x), FLC(A6, x);} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, less<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(stack<T> &S){while (!S.empty()) S.pop();} | |
template<class T0, class T1> inline void CLR(T0 &A0, T1 &A1){CLR(A0), CLR(A1);} | |
template<class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2){CLR(A0), CLR(A1), CLR(A2);} | |
template<class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);} | |
template<class T> inline void CLR(T &A, int n){REP(i, n) CLR(A[i]);} | |
template<class T> inline bool EPT(T &a){return a.empty();} | |
template<class T> inline T& SRT(T &A){sort(ALL(A)); return A;} | |
template<class T, class C> inline T& SRT(T &A, C B){sort(ALL(A), B); return A;} | |
template<class T> inline T& RVS(T &A){reverse(ALL(A)); return A;} | |
template<class T> inline T& UNQQ(T &A){A.resize(unique(ALL(A))-A.begin());return A;} | |
template<class T> inline T& UNQ(T &A){SRT(A);return UNQQ(A);} | |
//} | |
/** Constant List .. **/ //{ | |
const int MOD = int(1e9) + 7; | |
const int INF = 0x3f3f3f3f; | |
const LL INFF = 0x3f3f3f3f3f3f3f3fLL; | |
const DB EPS = 1e-9; | |
const DB OO = 1e20; | |
const DB PI = acos(-1.0); //M_PI; | |
const int dx[] = {-1, 0, 1, 0}; | |
const int dy[] = {0, 1, 0, -1}; | |
//} | |
/** Add On .. **/ //{ | |
// <<= '0. Nichi Joo ., //{ | |
template<class T> inline T& checkMin(T &a,const T b){if (b<a) a=b;return a;} | |
template<class T> inline T& checkMax(T &a,const T b){if (a<b) a=b;return a;} | |
template<class T> inline T& checkMin(T &a, T &b, const T x){checkMin(a, x), checkMin(b, x);return a;} | |
template<class T> inline T& checkMax(T &a, T &b, const T x){checkMax(a, x), checkMax(b, x);return a;} | |
template <class T, class C> inline T& checkMin(T& a, const T b, C c){if (c(b,a)) a = b;return a;} | |
template <class T, class C> inline T& checkMax(T& a, const T b, C c){if (c(a,b)) a = b;return a;} | |
template<class T> inline T min(T a, T b, T c){return min(min(a, b), c);} | |
template<class T> inline T max(T a, T b, T c){return max(max(a, b), c);} | |
template<class T> inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));} | |
template<class T> inline T max(T a, T b, T c, T d){return max(max(a, b), max(c, d));} | |
template<class T> inline T min(T a, T b, T c, T d, T e){return min(min(min(a,b),min(c,d)),e);} | |
template<class T> inline T max(T a, T b, T c, T d, T e){return max(max(max(a,b),max(c,d)),e);} | |
template<class T> inline T sqr(T a){return a*a;} | |
template<class T> inline T cub(T a){return a*a*a;} | |
template<class T> inline T ceil(T x, T y){return (x - 1) / y + 1;} | |
template<class T> T abs(T x){return x>0?x:-x;} | |
inline int sgn(DB x){return x < -EPS ? -1 : x > EPS;} | |
inline int sgn(DB x, DB y){return sgn(x - y);} | |
inline DB cos(DB a, DB b, DB c){return (sqr(a)+sqr(b)-sqr(c))/(2*a*b);} | |
inline DB cot(DB x){return 1./tan(x);}; | |
inline DB sec(DB x){return 1./cos(x);}; | |
inline DB csc(DB x){return 1./sin(x);}; | |
//} | |
// <<= '1. Bitwise Operation ., //{ | |
namespace BO{ | |
inline bool _1(int x, int i){return bool(x&1<<i);} | |
inline bool _1(LL x, int i){return bool(x&1LL<<i);} | |
inline LL _1(int i){return 1LL<<i;} | |
inline LL _U(int i){return _1(i) - 1;}; | |
inline int reverse_bits(int x){ | |
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa); | |
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc); | |
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0); | |
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00); | |
x = ((x >>16) & 0x0000ffff) | ((x <<16) & 0xffff0000); | |
return x; | |
} | |
inline LL reverse_bits(LL x){ | |
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL); | |
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL); | |
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL); | |
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL); | |
x = ((x >>16) & 0x0000ffff0000ffffLL) | ((x <<16) & 0xffff0000ffff0000LL); | |
x = ((x >>32) & 0x00000000ffffffffLL) | ((x <<32) & 0xffffffff00000000LL); | |
return x; | |
} | |
template<class T> inline bool odd(T x){return x&1;} | |
template<class T> inline bool even(T x){return !odd(x);} | |
template<class T> inline T low_bit(T x) {return x & -x;} | |
template<class T> inline T high_bit(T x) {T p = low_bit(x);while (p != x) x -= p, p = low_bit(x);return p;} | |
template<class T> inline T cover_bit(T x){T p = 1; while (p < x) p <<= 1;return p;} | |
template<class T> inline int cover_idx(T x){int p = 0; while (_1(p) < x ) ++p; return p;} | |
inline int clz(int x){return __builtin_clz(x);} | |
inline int clz(LL x){return __builtin_clzll(x);} | |
inline int ctz(int x){return __builtin_ctz(x);} | |
inline int ctz(LL x){return __builtin_ctzll(x);} | |
inline int lg2(int x){return !x ? -1 : 31 - clz(x);} | |
inline int lg2(LL x){return !x ? -1 : 63 - clz(x);} | |
inline int low_idx(int x){return !x ? -1 : ctz(x);} | |
inline int low_idx(LL x){return !x ? -1 : ctz(x);} | |
inline int high_idx(int x){return lg2(x);} | |
inline int high_idx(LL x){return lg2(x);} | |
inline int parity(int x){return __builtin_parity(x);} | |
inline int parity(LL x){return __builtin_parityll(x);} | |
inline int count_bits(int x){return __builtin_popcount(x);} | |
inline int count_bits(LL x){return __builtin_popcountll(x);} | |
} using namespace BO;//} | |
// <<= '2. Number Theory .,//{ | |
namespace NT{ | |
inline LL gcd(LL a, LL b){return __gcd(a, b);} | |
inline LL lcm(LL a, LL b){return a*b/gcd(a,b);} | |
inline void INC(int &a, int b){a += b; if (a >= MOD) a -= MOD;} | |
inline int sum(int a, int b){a += b; if (a >= MOD) a -= MOD; return a;} | |
inline void DEC(int &a, int b){a -= b; if (a < 0) a += MOD;} | |
inline int dff(int a, int b){a -= b; if (a < 0) a += MOD; return a;} | |
inline void MUL(int &a, int b){a = (LL)a * b % MOD;} | |
inline int pdt(int a, int b){return (LL)a * b % MOD;} | |
inline int gcd(int m, int n, int &x, int &y){ | |
x = 1, y = 0; int xx = 0, yy = 1, q; | |
while (1){ | |
q = m / n, m %= n; | |
if (!m){x = xx, y = yy; return n;} | |
DEC(x, pdt(q, xx)), DEC(y, pdt(q, yy)); | |
q = n / m, n %= m; | |
if (!n) return m; | |
DEC(xx, pdt(q, x)), DEC(yy, pdt(q, y)); | |
} | |
} | |
inline int sum(int a, int b, int c){return sum(a, sum(b, c));} | |
inline int sum(int a, int b, int c, int d){return sum(sum(a, b), sum(c, d));} | |
inline int pdt(int a, int b, int c){return pdt(a, pdt(b, c));} | |
inline int pdt(int a, int b, int c, int d){return pdt(pdt(a, b), pdt(c, d));} | |
inline int pow(int a, LL b){ | |
int c(1); while (b){ | |
if (b&1) MUL(c, a); | |
MUL(a, a), b >>= 1; | |
} | |
return c; | |
} | |
template<class T> inline T pow(T a, LL b){ | |
T c(1); while (b){ | |
if (b&1) c *= a; | |
a *= a, b >>= 1; | |
} | |
return c; | |
} | |
template<class T> inline T pow(T a, int b){ | |
return pow(a, (LL)b); | |
} | |
inline int _I(int b){ | |
int a = MOD, x1 = 0, x2 = 1, q; | |
while (true){ | |
q = a / b, a %= b; | |
if (!a) return (x2 + MOD) % MOD; | |
DEC(x1, pdt(q, x2)); | |
q = b / a, b %= a; | |
if (!b) return (x1 + MOD) % MOD; | |
DEC(x2, pdt(q, x1)); | |
} | |
} | |
inline void DIV(int &a, int b){MUL(a, _I(b));} | |
inline int qtt(int a, int b){return pdt(a, _I(b));} | |
struct Int{ | |
int val; | |
operator int() const{return val;} | |
Int(int val = 0):val(val){ | |
val %= MOD; if (val < 0) val += MOD; | |
} | |
Int(LL _val){ | |
_val %= MOD; if (_val < 0) _val += MOD; | |
val = _val; | |
} | |
Int& operator +=(const int& rhs){ | |
INC(val, rhs); | |
return *this; | |
} | |
Int operator +(const int& rhs) const{ | |
return sum(val, rhs); | |
} | |
Int& operator -=(const int& rhs){ | |
DEC(val, rhs); | |
return *this; | |
} | |
Int operator -(const int& rhs) const{ | |
return dff(val, rhs); | |
} | |
Int& operator *=(const int& rhs){ | |
MUL(val, rhs); | |
return *this; | |
} | |
Int operator *(const int& rhs) const{ | |
return pdt(val, rhs); | |
} | |
Int& operator /=(const int& rhs){ | |
DIV(val, rhs); | |
return *this; | |
} | |
Int operator /(const int& rhs) const{ | |
return qtt(val, rhs); | |
} | |
Int operator-()const{ | |
return MOD-*this; | |
} | |
}; | |
/* | |
Int Fact[N], Factt[N]; Int Binom(int n, int m){ | |
return Fact[n] * Factt[m] * Factt[n-m]; | |
} | |
*/ | |
/* | |
Fact[0] = 1; REP_1(i, N-1) Fact[i] = Fact[i-1] * i; | |
Factt[N-1] = _I(Fact[N-1]); DWN(i, N, 1) Factt[i-1] = Factt[i] * i; | |
*/ | |
/* | |
int Binom[N][N]; | |
REP(i, N){Binom[i][0] = 1; REP_1(j, i) Binom[i][j] = Binom[i-1][j-1] + Binom[i-1][j];} | |
*/ | |
/* | |
const int PMAX = 1; | |
VI P; bitset<PMAX> isP; | |
void sieve(){ | |
FOR(i, 2, PMAX){ | |
if (!isP[i]) P.PB(i); | |
for (int j=0;j<SZ(P)&&i*P[j]<PMAX;++j){ | |
isP[i*P[j]]=1; if (!(i%P[j])) break; | |
} | |
} | |
} | |
*/ | |
/* | |
inline int phi(int n){ | |
int res = n; for (int i=2;sqr(i)<=n;++i) if (!(n%i)){ | |
DEC(res, qtt(res, i)); | |
do{n /= i;} while(!(n%i)); | |
} | |
if (n != 1) | |
DEC(res, qtt(res, n)); | |
return res; | |
} | |
*/ | |
/*LL d, x, y; void exGcd(LL a, LL b){ | |
if(!b) x = 1, y = 0, d = a; | |
else{ | |
exGcd(b, a%b); LL t = y; | |
y = x - (a/b)*y, x = t; | |
} | |
}*/ | |
} using namespace NT;//} | |
// <<= '9. Comutational Geometry .,//{ | |
namespace CG{ | |
#define cPo const Po& | |
#define cLine const Line& | |
#define cSeg const Seg& | |
inline DB dist2(DB x,DB y){return sqr(x)+sqr(y);} | |
struct Po{ | |
DB x,y;Po(DB x=0,DB y=0):x(x),y(y){} | |
void in(){RF(x,y);}void out(){printf("(%.2f,%.2f)",x,y);} | |
inline friend istream&operator>>(istream&i,Po&p){return i>>p.x>>p.y;} | |
inline friend ostream&operator<<(ostream&o,Po p){return o<<"("<<p.x<<", "<<p.y<< ")";} | |
Po operator-()const{return Po(-x,-y);} | |
Po&operator+=(cPo p){x+=p.x,y+=p.y;rTs;}Po&operator-=(cPo p){x-=p.x,y-=p.y;rTs;} | |
Po&operator*=(DB k){x*=k,y*=k;rTs;}Po&operator/=(DB k){x/=k,y/=k;rTs;} | |
Po&operator*=(cPo p){rTs=Ts*p;}Po&operator/=(cPo p){rTs=Ts/p;} | |
Po operator+(cPo p)const{return Po(x+p.x,y+p.y);}Po operator-(cPo p)const{return Po(x-p.x,y-p.y);} | |
Po operator*(DB k)const{return Po(x*k,y*k);}Po operator/(DB k)const{return Po(x/k,y/k);} | |
Po operator*(cPo p)const{return Po(x*p.x-y*p.y,y*p.x+x*p.y);}Po operator/(cPo p)const{return Po(x*p.x+y*p.y,y*p.x-x*p.y)/p.len2();} | |
bool operator==(cPo p)const{return!sgn(x,p.x)&&!sgn(y,p.y);};bool operator!=(cPo p)const{return sgn(x,p.x)||sgn(y,p.y);} | |
bool operator<(cPo p)const{return sgn(x,p.x)<0||!sgn(x,p.x)&&sgn(y,p.y)<0;}bool operator<=(cPo p)const{return sgn(x,p.x)<0||!sgn(x,p.x)&&sgn(y,p.y)<=0;} | |
bool operator>(cPo p)const{return!(Ts<=p);}bool operator >=(cPo p)const{return!(Ts<p);} | |
DB len2()const{return dist2(x,y);}DB len()const{return sqrt(len2());}DB arg()const{return atan2(y,x);} | |
Po&_1(){rTs/=len();}Po&conj(){y=-y;rTs;}Po<(){swap(x,y),x=-x;rTs;}Po&rt(){swap(x,y),y=-y;rTs;} | |
Po&rot(DB a,cPo o=Po()){Ts-=o;Ts*=Po(cos(a),sin(a));rTs+=o;} | |
}; | |
inline DB dot(DB x1,DB y1,DB x2,DB y2){return x1*x2+y1*y2;} | |
inline DB dot(cPo a,cPo b){return dot(a.x,a.y,b.x,b.y);} | |
inline DB dot(cPo p0,cPo p1,cPo p2){return dot(p1-p0,p2-p0);} | |
inline DB det(DB x1,DB y1,DB x2,DB y2){return x1*y2-x2*y1;} | |
inline DB det(cPo a,cPo b){return det(a.x,a.y,b.x,b.y);} | |
inline DB det(cPo p0,cPo p1,cPo p2){return det(p1-p0,p2-p0);} | |
inline DB ang(cPo p0,cPo p1){return acos(dot(p0,p1)/p0.len()/p1.len());} | |
inline DB ang(cPo p0,cPo p1,cPo p2){return ang(p1-p0,p2-p0);} | |
inline DB ang(cPo p0,cPo p1,cPo p2,cPo p3){return ang(p1-p0,p3-p2);} | |
inline DB dist2(const Po &a, const Po &b){return dist2(a.x-b.x, a.y-b.y);} | |
template<class T1, class T2> inline int dett(const T1 &x, const T2 &y){return sgn(det(x, y));} | |
template<class T1, class T2, class T3> inline int dett(const T1 &x, const T2 &y, const T3 &z){return sgn(det(x, y, z));} | |
template<class T1, class T2, class T3, class T4> inline int dett(const T1 &x, const T2 &y, const T3 &z, const T4 &w){return sgn(det(x, y, z, w));} | |
template<class T1, class T2> inline int dott(const T1 &x, const T2 &y){return sgn(dot(x, y));} | |
template<class T1, class T2, class T3> inline int dott(const T1 &x, const T2 &y, const T3 &z){return sgn(dot(x, y, z));} | |
template<class T1, class T2, class T3, class T4> inline int dott(const T1 &x, const T2 &y, const T3 &z, const T4 &w){return sgn(dot(x, y, z, w));} | |
template<class T1, class T2> inline DB arg(const T1 &x, const T2 &y){DB a=ang(x,y);return~dett(x,y)?a:2*PI-a;} | |
template<class T1, class T2, class T3> inline DB arg(const T1 &x, const T2 &y, const T3 &z){DB a=ang(x,y,z);return~dett(x,y,z)?a:2*PI-a;} | |
template<class T1, class T2, class T3, class T4> inline DB arg(const T1 &x, const T2 &y, const T3 &z, const T4 &w){DB a=ang(x,y,z,w);return~dett(x,y,z,w)?a:2*PI-a;} | |
template<class T1, class T2> inline DB dist(const T1 &x, const T2 &y){return sqrt(dist2(x, y));} | |
template<class T1, class T2, class T3> inline DB dist(const T1 &x, const T2 &y, const T3 &z){return sqrt(dist2(x, y, z));} | |
inline Po _1(Po p){return p._1();}inline Po conj(Po p){return p.conj();} | |
inline Po lt(Po p){return p.lt();}inline Po rt(Po p){return p.rt();} | |
inline Po rot(Po p,DB a,cPo o=Po()){return p.rot(a,o);} | |
inline Po operator *(DB k,cPo p){return p*k;} | |
inline Po operator /(DB k,cPo p){return conj(p)*k/p.len2();} | |
typedef vector<Po> VP; | |
struct Line{ | |
Po a,b;Line(cPo a=Po(),cPo b=Po()):a(a),b(b){} | |
Line(DB x0,DB y0,DB x1,DB y1):a(Po(x0,y0)),b(Po(x1,y1)){} | |
Line(cLine l):a(l.a),b(l.b){} | |
//Ax+By+C=0 | |
Line(DB A,DB B,DB C){ | |
C=-C;if(!::sgn(A))a=Po(0,C/B),b=Po(1,C/B); | |
else if(!::sgn(B))a=Po(C/A,0),b=Po(C/A,1); | |
else a=Po(0,C/B),b=Po(1,(C-A)/B); | |
} | |
void in(){a.in(),b.in();} | |
inline friend istream&operator>>(istream&i,Line& p){return i>>p.a>>p.b;} | |
inline friend ostream&operator<<(ostream&o,Line p){return o<<p.a<<"-"<< p.b;} | |
Line operator+(cPo x)const{return Line(a+x,b+x);} | |
Line operator-(cPo x)const{return Line(a-x,b-x);} | |
Line operator*(DB k)const{return Line(a*k,b*k);} | |
Line operator/(DB k)const{return Line(a/k,b/k);} | |
Po operator*(cLine)const; | |
Po d()const{return b-a;}DB len2()const{return d().len2();}DB len()const{return d().len();}DB arg()const{return d().arg();} | |
int sgn(cPo p)const{return dett(a, b, p);} | |
int sgn(cLine)const; | |
bool sameSgn(cPo p1,cPo p2)const{return sgn(p1)==sgn(p2);} | |
void getEquation(DB&K,DB&B)const{ | |
K = ::sgn(a.x, b.x) ? (b.y-a.y)/(b.x-a.x) : OO; | |
B = a.y - K*a.x; | |
} | |
void getEquation(DB&A,DB&B,DB&C)const{A=a.y-b.y,B=b.x-a.x,C=det(a, b);} | |
Line&push(DB r){ // 正数右手螺旋向里 | |
Po v=d()._1().lt()*r;a+=v,b+=v; rTs; | |
} | |
}; | |
inline DB dot(cLine l1,cLine l2){return dot(l1.d(),l2.d());} | |
inline DB dot(cLine l,cPo p){return dot(l.a,l.b,p);} | |
inline DB dot(cPo p,cLine l){return dot(p,l.a,l.b);} | |
inline DB det(cLine l1,cLine l2){return det(l1.d(),l2.d());} | |
inline DB det(cLine l,cPo p){return det(l.a,l.b,p);} | |
inline DB det(cPo p,cLine l){return det(p,l.a,l.b);} | |
inline DB ang(cLine l0,cLine l1){return ang(l0.d(),l1.d());} | |
inline DB ang(cLine l,cPo p){return ang(l.a,l.b,p);} | |
inline DB ang(cPo p,cLine l){return ang(p,l.a,l.b);} | |
inline int Line::sgn(cLine l)const{return dett(Ts, l);} | |
inline Po Line::operator*(cLine l)const{return a+d()*det(a,l)/det(Ts,l);} | |
inline Po operator&(cPo p,cLine l){return l*Line(p,p+l.d().lt());} | |
inline Po operator%(cPo p,cLine l){return p&l*2-p;} | |
inline Line push(Line l, DB r){return l.push(r);} | |
struct Seg: public Line{ | |
Seg(cPo a=Po(),cPo b=Po()):Line(a,b){} | |
Seg(DB x0,DB y0,DB x1,DB y1):Line(x0,y0,x1,y1){} | |
Seg(cLine l):Line(l){} | |
Seg(const Po &a,DB alpha):Line(a,alpha){} | |
Seg(DB A,DB B,DB C):Line(A,B,C){} | |
inline int sgn(cPo p)const; | |
inline int sgn(cLine l)const; | |
inline bool qrt(cSeg l)const; | |
inline int sgn(cSeg l)const; | |
}; | |
// -1不相交 0相交(不规范) 1相交(规范) | |
inline int Seg::sgn(cPo p)const{return -dott(p,a,b);} | |
inline int Seg::sgn(cLine l)const{return sgn(Ts*l);} | |
// quick_rejection_test | |
inline bool Seg::qrt(cSeg l)const{ | |
return min(a.x,b.x)<=max(l.a.x,l.b.x)&&min(l.a.x,l.b.x)<=max(a.x,b.x)&& | |
min(a.y,b.y)<=max(l.a.y,l.b.y)&&min(l.a.y,l.b.y)<=max(a.y,b.y); | |
} | |
inline int Seg::sgn(cSeg l)const{ | |
if (!qrt(l)) return -1; | |
/*return | |
(dett(a,b,l.a)*dett(a,b,l.b)<=0 && | |
dett(l.a,l.b,a)*dett(l.a,l.b,b)<=0)?1:-1;*/ | |
int d1=dett(a,b,l.a),d2=dett(a,b,l.b),d3=dett(l.a,l.b,a),d4=dett(l.a,l.b,b); | |
if ((d1^d2)==-2&&(d3^d4)==-2)return 1; | |
return ((!d1&&dott(l.a-a,l.a-b)<=0)||(!d2&&dott(l.b-a,l.b-b)<=0)|| | |
(!d3&&dott(a-l.a,a-l.b)<=0)||(!d4&&dott(b-l.a,b-l.b)<=0))?0:-1; | |
} | |
//inline DB dist2(cLine l,cPo p){return sqr(fabs(dot(lt(l.d()), p-l.a)))/l.len2();} | |
inline DB dist2(cLine l,cPo p){return sqr(fabs(det(l.d(), p-l.a)))/l.len2();} | |
inline DB dist2(cLine l1,cLine l2){return dett(l1,l2)?0:dist2(l1,l2.a);} | |
inline DB dist2(cSeg l,cPo p){ | |
Po pa = p - l.a, pb = p - l.b; | |
if (dott(l.d(), pa) <= 0) return pa.len2(); | |
if (dott(l.d(), pb) >= 0) return pb.len2(); | |
return dist2(Line(l), p); | |
} | |
inline DB dist2(cSeg s,cLine l){ | |
Po v1=s.a-l.a,v2=s.b-l.a;DB d1=det(l.d(),v1),d2=det(l.d(),v2); | |
return sgn(d1)!=sgn(d2) ? 0 : sqr(min(fabs(d1), fabs(d2)))/l.len2(); | |
} | |
inline DB dist2(cSeg l1,cSeg l2){ | |
if (~l1.sgn(l2)) return 0; | |
else return min(dist2(l2,l1.a), dist2(l2,l1.b), dist2(l1,l2.a), dist2(l1,l2.b)); | |
} | |
template<class T1, class T2> inline DB dist2(const T1& a, const T2& b){ | |
return dist2(b, a); | |
} | |
Po getPo(){Po p;p.in();return p;} | |
Line getLine(){Line l;l.in();return l;} | |
DB getArea(const VP& P){DB z=0;FOR(i,1,SZ(P))z+=det(P[i-1],P[i]);return z;} | |
DB getPeri(const VP& P){DB z=0;FOR(i,1,SZ(P))z+=dist(P[i-1],P[i]);return z;} | |
} using namespace CG;//} | |
//} | |
/** I/O Accelerator Interface .. **/ //{ | |
#define g (c=getchar()) | |
#define d isdigit(g) | |
#define p x=x*10+c-'0' | |
#define n x=x*10+'0'-c | |
#define pp l/=10,p | |
#define nn l/=10,n | |
template<class T> inline T& RD(T &x){ | |
char c;while(!d);x=c-'0';while(d)p; | |
return x; | |
} | |
template<class T> inline T& RDD(T &x){ | |
char c;while(g,c!='-'&&!isdigit(c)); | |
if (c=='-'){x='0'-g;while(d)n;} | |
else{x=c-'0';while(d)p;} | |
return x; | |
} | |
inline DB& RF(DB &x){ | |
//scanf("%lf", &x); | |
char c;while(g,c!='-'&&c!='.'&&!isdigit(c)); | |
if(c=='-')if(g=='.'){x=0;DB l=1;while(d)nn;x*=l;} | |
else{x='0'-c;while(d)n;if(c=='.'){DB l=1;while(d)nn;x*=l;}} | |
else if(c=='.'){x=0;DB l=1;while(d)pp;x*=l;} | |
else{x=c-'0';while(d)p;if(c=='.'){DB l=1;while(d)pp;x*=l;}} | |
return x; | |
} | |
#undef nn | |
#undef pp | |
#undef n | |
#undef p | |
#undef d | |
#undef g | |
inline char* RS(char *s){ | |
//gets(s); | |
scanf("%s", s); | |
return s; | |
} | |
LL last_ans; int Case; template<class T> inline void OT(const T &x){ | |
//printf("Case #%d: ", ++Case); | |
//printf("%lld\n", x); | |
printf("%.3f\n", x); | |
//printf("%d\n", x); | |
//cout << x << endl; | |
//last_ans = x; | |
} | |
//} | |
//}/* .................................................................................................................................. */ | |
const int N = int(2e5) + 9; | |
int x[N], y[N], n; DB slope[N]; | |
int D; | |
inline DB yy(int i, DB xx){ | |
return y[i] + (xx-x[i])*slope[i]; | |
} | |
inline DB s(int i, DB st, DB ed){ | |
return (ed-st)*(yy(i,st)+yy(i,ed)); | |
} | |
int main(){ | |
#ifndef ONLINE_JUDGE | |
freopen("in.txt", "r", stdin); | |
//freopen("out.txt", "w", stdout); | |
#endif | |
Rush{ | |
RD(n); RD(); REP(i, n) RD(x[i], y[i]); RD(D)*=2; | |
REP(i, n-1) slope[i] = (DB)(y[i+1]-y[i])/(x[i+1]-x[i]); | |
DB res = 0, pre = 0; int r; REP_N(r, n-1){ | |
if (x[r+1] >= D) break; | |
pre += s(r,x[r],x[r+1]); | |
} | |
checkMax(res, pre += s(r, x[r], D)); | |
int l=0,ll=0,rr=D;r+=rr==x[r+1]; | |
for (;r<n-1;l+=ll==x[l+1],r+=rr==x[r+1]){ | |
int d = min(x[r+1]-rr, x[l+1]-ll); DB a = slope[r]-slope[l], b = (yy(r,rr)-yy(l,ll))*2; if (sgn(a)){ | |
DB dd = -b/(2*a); if (sgn(.0, dd) < 0 && sgn(dd, DB(d)) < 0){ | |
checkMax(res, pre-(b*b/a/4)); | |
} | |
} | |
checkMax(res, pre += s(r,rr,rr+d)-s(l,ll,ll+d)); | |
ll+=d,rr+=d; | |
} | |
OT(res/D/2); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** Micro Mezz Macro Flation -- Overheated Economy ., Last Update: May. 7th 2014 **/ //{ | |
/** Header .. **/ //{ | |
#pragma comment(linker, "/STACK:36777216") | |
//#pragma GCC optimize ("O2") | |
#define LOCAL | |
//#include "testlib.h" | |
#include <functional> | |
#include <algorithm> | |
#include <iostream> | |
#include <fstream> | |
#include <sstream> | |
#include <iomanip> | |
#include <numeric> | |
#include <cstring> | |
#include <climits> | |
#include <cassert> | |
#include <complex> | |
#include <cstdio> | |
#include <string> | |
#include <vector> | |
#include <bitset> | |
#include <queue> | |
#include <stack> | |
#include <cmath> | |
#include <ctime> | |
#include <list> | |
#include <set> | |
#include <map> | |
//#include <tr1/unordered_set> | |
//#include <tr1/unordered_map> | |
//#include <array> | |
using namespace std; | |
#define REP(i, n) for (int i=0;i<n;++i) | |
#define FOR(i, a, b) for (int i=a;i<b;++i) | |
#define DWN(i, b, a) for (int i=b-1;i>=a;--i) | |
#define REP_1(i, n) for (int i=1;i<=n;++i) | |
#define FOR_1(i, a, b) for (int i=a;i<=b;++i) | |
#define DWN_1(i, b, a) for (int i=b;i>=a;--i) | |
#define REP_C(i, n) for (int n____=n,i=0;i<n____;++i) | |
#define FOR_C(i, a, b) for (int b____=b,i=a;i<b____;++i) | |
#define DWN_C(i, b, a) for (int a____=a,i=b-1;i>=a____;--i) | |
#define REP_N(i, n) for (i=0;i<n;++i) | |
#define FOR_N(i, a, b) for (i=a;i<b;++i) | |
#define DWN_N(i, b, a) for (i=b-1;i>=a;--i) | |
#define REP_1_C(i, n) for (int n____=n,i=1;i<=n____;++i) | |
#define FOR_1_C(i, a, b) for (int b____=b,i=a;i<=b____;++i) | |
#define DWN_1_C(i, b, a) for (int a____=a,i=b;i>=a____;--i) | |
#define REP_1_N(i, n) for (i=1;i<=n;++i) | |
#define FOR_1_N(i, a, b) for (i=a;i<=b;++i) | |
#define DWN_1_N(i, b, a) for (i=b;i>=a;--i) | |
#define REP_C_N(i, n) for (int n____=(i=0,n);i<n____;++i) | |
#define FOR_C_N(i, a, b) for (int b____=(i=0,b);i<b____;++i) | |
#define DWN_C_N(i, b, a) for (int a____=(i=b-1,a);i>=a____;--i) | |
#define REP_1_C_N(i, n) for (int n____=(i=1,n);i<=n____;++i) | |
#define FOR_1_C_N(i, a, b) for (int b____=(i=a,b);i<=b____;++i) | |
#define DWN_1_C_N(i, b, a) for (int a____=(i=b,a);i>=a____;--i) | |
#define ECH(it, A) for (__typeof(A.begin()) it=A.begin(); it != A.end(); ++it) | |
#define REP_S(i, str) for (char*i=str;*i;++i) | |
#define REP_L(i, hd, suc) for (int i=hd;i;i=suc[i]) | |
#define REP_G(i, u) REP_L(i,hd[u],suc) | |
#define REP_SS(x, s) for (int x=s;x;x=(x-1)&s) | |
#define DO(n) for ( int ____n = n; ____n-->0; ) | |
#define REP_2(i, j, n, m) REP(i, n) REP(j, m) | |
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m) | |
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l) | |
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l) | |
#define REP_4(i, j, k, ii, n, m, l, nn) REP(i, n) REP(j, m) REP(k, l) REP(ii, nn) | |
#define REP_4_1(i, j, k, ii, n, m, l, nn) REP_1(i, n) REP_1(j, m) REP_1(k, l) REP_1(ii, nn) | |
#define ALL(A) A.begin(), A.end() | |
#define LLA(A) A.rbegin(), A.rend() | |
#define CPY(A, B) memcpy(A, B, sizeof(A)) | |
#define INS(A, P, B) A.insert(A.begin() + P, B) | |
#define ERS(A, P) A.erase(A.begin() + P) | |
#define LBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define UBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define CTN(T, x) (T.find(x) != T.end()) | |
#define SZ(A) int((A).size()) | |
#define PB push_back | |
#define MP(A, B) make_pair(A, B) | |
#define PTT pair<T, T> | |
#define Ts *this | |
#define rTs return Ts | |
#define fi first | |
#define se second | |
#define re real() | |
#define im imag() | |
#define Rush for(int ____T=RD(); ____T--;) | |
#define Display(A, n, m) { \ | |
REP(i, n){ \ | |
REP(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m-1] << endl; \ | |
} \ | |
} | |
#define Display_1(A, n, m) { \ | |
REP_1(i, n){ \ | |
REP_1(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m] << endl; \ | |
} \ | |
} | |
typedef long long LL; | |
//typedef long double DB; | |
typedef double DB; | |
typedef unsigned uint; | |
typedef unsigned long long uLL; | |
typedef vector<int> VI; | |
typedef vector<char> VC; | |
typedef vector<string> VS; | |
typedef vector<LL> VL; | |
typedef vector<DB> VF; | |
typedef set<int> SI; | |
typedef set<string> SS; | |
typedef map<int, int> MII; | |
typedef map<string, int> MSI; | |
typedef pair<int, int> PII; | |
typedef pair<LL, LL> PLL; | |
typedef vector<PII> VII; | |
typedef vector<VI> VVI; | |
typedef vector<VII> VVII; | |
template<class T> inline T& RD(T &); | |
template<class T> inline void OT(const T &); | |
//inline int RD(){int x; return RD(x);} | |
inline LL RD(){LL x; return RD(x);} | |
inline DB& RF(DB &); | |
inline DB RF(){DB x; return RF(x);} | |
inline char* RS(char *s); | |
inline char& RC(char &c); | |
inline char RC(); | |
inline char& RC(char &c){scanf(" %c", &c); return c;} | |
inline char RC(){char c; return RC(c);} | |
//inline char& RC(char &c){c = getchar(); return c;} | |
//inline char RC(){return getchar();} | |
template<class T> inline T& RDD(T &); | |
inline LL RDD(){LL x; return RDD(x);} | |
template<class T0, class T1> inline T0& RD(T0 &x0, T1 &x1){RD(x0), RD(x1); return x0;} | |
template<class T0, class T1, class T2> inline T0& RD(T0 &x0, T1 &x1, T2 &x2){RD(x0), RD(x1), RD(x2); return x0;} | |
template<class T0, class T1, class T2, class T3> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3){RD(x0), RD(x1), RD(x2), RD(x3); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); return x0;} | |
template<class T0, class T1> inline void OT(const T0 &x0, const T1 &x1){OT(x0), OT(x1);} | |
template<class T0, class T1, class T2> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2){OT(x0), OT(x1), OT(x2);} | |
template<class T0, class T1, class T2, class T3> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3){OT(x0), OT(x1), OT(x2), OT(x3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5, const T6 &x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);} | |
inline char& RC(char &a, char &b){RC(a), RC(b); return a;} | |
inline char& RC(char &a, char &b, char &c){RC(a), RC(b), RC(c); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d){RC(a), RC(b), RC(c), RC(d); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e){RC(a), RC(b), RC(c), RC(d), RC(e); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g); return a;} | |
inline DB& RF(DB &a, DB &b){RF(a), RF(b); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c){RF(a), RF(b), RF(c); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d){RF(a), RF(b), RF(c), RF(d); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e){RF(a), RF(b), RF(c), RF(d), RF(e); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f, DB &g){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g); return a;} | |
inline void RS(char *s1, char *s2){RS(s1), RS(s2);} | |
inline void RS(char *s1, char *s2, char *s3){RS(s1), RS(s2), RS(s3);} | |
template<class T0,class T1>inline void RDD(T0&a, T1&b){RDD(a),RDD(b);} | |
template<class T0,class T1,class T2>inline void RDD(T0&a, T1&b, T2&c){RDD(a),RDD(b),RDD(c);} | |
template<class T> inline void RST(T &A){memset(A, 0, sizeof(A));} | |
template<class T> inline void FLC(T &A, int x){memset(A, x, sizeof(A));} | |
template<class T> inline void CLR(T &A){A.clear();} | |
template<class T0, class T1> inline void RST(T0 &A0, T1 &A1){RST(A0), RST(A1);} | |
template<class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2){RST(A0), RST(A1), RST(A2);} | |
template<class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3){RST(A0), RST(A1), RST(A2), RST(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);} | |
template<class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x){FLC(A0, x), FLC(A1, x);} | |
template<class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x);} | |
template<class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x), FLC(A6, x);} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, less<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(stack<T> &S){while (!S.empty()) S.pop();} | |
template<class T0, class T1> inline void CLR(T0 &A0, T1 &A1){CLR(A0), CLR(A1);} | |
template<class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2){CLR(A0), CLR(A1), CLR(A2);} | |
template<class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);} | |
template<class T> inline void CLR(T &A, int n){REP(i, n) CLR(A[i]);} | |
template<class T> inline bool EPT(T &a){return a.empty();} | |
template<class T> inline T& SRT(T &A){sort(ALL(A)); return A;} | |
template<class T, class C> inline T& SRT(T &A, C B){sort(ALL(A), B); return A;} | |
template<class T> inline T& RVS(T &A){reverse(ALL(A)); return A;} | |
template<class T> inline T& UNQQ(T &A){A.resize(unique(ALL(A))-A.begin());return A;} | |
template<class T> inline T& UNQ(T &A){SRT(A);return UNQQ(A);} | |
//} | |
/** Constant List .. **/ //{ | |
const int MOD = int(1e9) + 7; | |
const int INF = 0x3f3f3f3f; | |
const LL INFF = 0x3f3f3f3f3f3f3f3fLL; | |
const DB EPS = 1e-9; | |
const DB OO = 1e20; | |
const DB PI = acos(-1.0); //M_PI; | |
const int dx[] = {-1, 0, 1, 0}; | |
const int dy[] = {0, 1, 0, -1}; | |
//} | |
/** Add On .. **/ //{ | |
// <<= '0. Nichi Joo ., //{ | |
template<class T> inline T& checkMin(T &a,const T b){if (b<a) a=b;return a;} | |
template<class T> inline T& checkMax(T &a,const T b){if (a<b) a=b;return a;} | |
template<class T> inline T& checkMin(T &a, T &b, const T x){checkMin(a, x), checkMin(b, x);return a;} | |
template<class T> inline T& checkMax(T &a, T &b, const T x){checkMax(a, x), checkMax(b, x);return a;} | |
template <class T, class C> inline T& checkMin(T& a, const T b, C c){if (c(b,a)) a = b;return a;} | |
template <class T, class C> inline T& checkMax(T& a, const T b, C c){if (c(a,b)) a = b;return a;} | |
template<class T> inline T min(T a, T b, T c){return min(min(a, b), c);} | |
template<class T> inline T max(T a, T b, T c){return max(max(a, b), c);} | |
template<class T> inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));} | |
template<class T> inline T max(T a, T b, T c, T d){return max(max(a, b), max(c, d));} | |
template<class T> inline T min(T a, T b, T c, T d, T e){return min(min(min(a,b),min(c,d)),e);} | |
template<class T> inline T max(T a, T b, T c, T d, T e){return max(max(max(a,b),max(c,d)),e);} | |
template<class T> inline T sqr(T a){return a*a;} | |
template<class T> inline T cub(T a){return a*a*a;} | |
template<class T> inline T ceil(T x, T y){return (x - 1) / y + 1;} | |
template<class T> T abs(T x){return x>0?x:-x;} | |
inline int sgn(DB x){return x < -EPS ? -1 : x > EPS;} | |
inline int sgn(DB x, DB y){return sgn(x - y);} | |
inline DB cos(DB a, DB b, DB c){return (sqr(a)+sqr(b)-sqr(c))/(2*a*b);} | |
inline DB cot(DB x){return 1./tan(x);}; | |
inline DB sec(DB x){return 1./cos(x);}; | |
inline DB csc(DB x){return 1./sin(x);}; | |
//} | |
// <<= '1. Bitwise Operation ., //{ | |
namespace BO{ | |
inline bool _1(int x, int i){return bool(x&1<<i);} | |
inline bool _1(LL x, int i){return bool(x&1LL<<i);} | |
inline LL _1(int i){return 1LL<<i;} | |
inline LL _U(int i){return _1(i) - 1;}; | |
inline int reverse_bits(int x){ | |
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa); | |
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc); | |
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0); | |
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00); | |
x = ((x >>16) & 0x0000ffff) | ((x <<16) & 0xffff0000); | |
return x; | |
} | |
inline LL reverse_bits(LL x){ | |
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL); | |
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL); | |
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL); | |
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL); | |
x = ((x >>16) & 0x0000ffff0000ffffLL) | ((x <<16) & 0xffff0000ffff0000LL); | |
x = ((x >>32) & 0x00000000ffffffffLL) | ((x <<32) & 0xffffffff00000000LL); | |
return x; | |
} | |
template<class T> inline bool odd(T x){return x&1;} | |
template<class T> inline bool even(T x){return !odd(x);} | |
template<class T> inline T low_bit(T x) {return x & -x;} | |
template<class T> inline T high_bit(T x) {T p = low_bit(x);while (p != x) x -= p, p = low_bit(x);return p;} | |
template<class T> inline T cover_bit(T x){T p = 1; while (p < x) p <<= 1;return p;} | |
template<class T> inline int cover_idx(T x){int p = 0; while (_1(p) < x ) ++p; return p;} | |
inline int clz(int x){return __builtin_clz(x);} | |
inline int clz(LL x){return __builtin_clzll(x);} | |
inline int ctz(int x){return __builtin_ctz(x);} | |
inline int ctz(LL x){return __builtin_ctzll(x);} | |
inline int lg2(int x){return !x ? -1 : 31 - clz(x);} | |
inline int lg2(LL x){return !x ? -1 : 63 - clz(x);} | |
inline int low_idx(int x){return !x ? -1 : ctz(x);} | |
inline int low_idx(LL x){return !x ? -1 : ctz(x);} | |
inline int high_idx(int x){return lg2(x);} | |
inline int high_idx(LL x){return lg2(x);} | |
inline int parity(int x){return __builtin_parity(x);} | |
inline int parity(LL x){return __builtin_parityll(x);} | |
inline int count_bits(int x){return __builtin_popcount(x);} | |
inline int count_bits(LL x){return __builtin_popcountll(x);} | |
} using namespace BO;//} | |
// <<= '2. Number Theory .,//{ | |
namespace NT{ | |
inline LL gcd(LL a, LL b){return __gcd(a, b);} | |
inline LL lcm(LL a, LL b){return a*b/gcd(a,b);} | |
inline void INC(int &a, int b){a += b; if (a >= MOD) a -= MOD;} | |
inline int sum(int a, int b){a += b; if (a >= MOD) a -= MOD; return a;} | |
inline void DEC(int &a, int b){a -= b; if (a < 0) a += MOD;} | |
inline int dff(int a, int b){a -= b; if (a < 0) a += MOD; return a;} | |
inline void MUL(int &a, int b){a = (LL)a * b % MOD;} | |
inline int pdt(int a, int b){return (LL)a * b % MOD;} | |
inline int gcd(int m, int n, int &x, int &y){ | |
x = 1, y = 0; int xx = 0, yy = 1, q; | |
while (1){ | |
q = m / n, m %= n; | |
if (!m){x = xx, y = yy; return n;} | |
DEC(x, pdt(q, xx)), DEC(y, pdt(q, yy)); | |
q = n / m, n %= m; | |
if (!n) return m; | |
DEC(xx, pdt(q, x)), DEC(yy, pdt(q, y)); | |
} | |
} | |
inline int sum(int a, int b, int c){return sum(a, sum(b, c));} | |
inline int sum(int a, int b, int c, int d){return sum(sum(a, b), sum(c, d));} | |
inline int pdt(int a, int b, int c){return pdt(a, pdt(b, c));} | |
inline int pdt(int a, int b, int c, int d){return pdt(pdt(a, b), pdt(c, d));} | |
inline int pow(int a, LL b){ | |
int c(1); while (b){ | |
if (b&1) MUL(c, a); | |
MUL(a, a), b >>= 1; | |
} | |
return c; | |
} | |
template<class T> inline T pow(T a, LL b){ | |
T c(1); while (b){ | |
if (b&1) c *= a; | |
a *= a, b >>= 1; | |
} | |
return c; | |
} | |
template<class T> inline T pow(T a, int b){ | |
return pow(a, (LL)b); | |
} | |
inline int _I(int b){ | |
int a = MOD, x1 = 0, x2 = 1, q; | |
while (true){ | |
q = a / b, a %= b; | |
if (!a) return (x2 + MOD) % MOD; | |
DEC(x1, pdt(q, x2)); | |
q = b / a, b %= a; | |
if (!b) return (x1 + MOD) % MOD; | |
DEC(x2, pdt(q, x1)); | |
} | |
} | |
inline void DIV(int &a, int b){MUL(a, _I(b));} | |
inline int qtt(int a, int b){return pdt(a, _I(b));} | |
struct Int{ | |
int val; | |
operator int() const{return val;} | |
Int(int val = 0):val(val){ | |
val %= MOD; if (val < 0) val += MOD; | |
} | |
Int(LL _val){ | |
_val %= MOD; if (_val < 0) _val += MOD; | |
val = _val; | |
} | |
Int& operator +=(const int& rhs){ | |
INC(val, rhs); | |
return *this; | |
} | |
Int operator +(const int& rhs) const{ | |
return sum(val, rhs); | |
} | |
Int& operator -=(const int& rhs){ | |
DEC(val, rhs); | |
return *this; | |
} | |
Int operator -(const int& rhs) const{ | |
return dff(val, rhs); | |
} | |
Int& operator *=(const int& rhs){ | |
MUL(val, rhs); | |
return *this; | |
} | |
Int operator *(const int& rhs) const{ | |
return pdt(val, rhs); | |
} | |
Int& operator /=(const int& rhs){ | |
DIV(val, rhs); | |
return *this; | |
} | |
Int operator /(const int& rhs) const{ | |
return qtt(val, rhs); | |
} | |
Int operator-()const{ | |
return MOD-*this; | |
} | |
}; | |
/* | |
Int Fact[N], Factt[N]; Int Binom(int n, int m){ | |
return Fact[n] * Factt[m] * Factt[n-m]; | |
} | |
*/ | |
/* | |
Fact[0] = 1; REP_1(i, N-1) Fact[i] = Fact[i-1] * i; | |
Factt[N-1] = _I(Fact[N-1]); DWN(i, N, 1) Factt[i-1] = Factt[i] * i; | |
*/ | |
/* | |
int Binom[N][N]; | |
REP(i, N){Binom[i][0] = 1; REP_1(j, i) Binom[i][j] = Binom[i-1][j-1] + Binom[i-1][j];} | |
*/ | |
/* | |
const int PMAX = 1; | |
VI P; bitset<PMAX> isP; | |
void sieve(){ | |
FOR(i, 2, PMAX){ | |
if (!isP[i]) P.PB(i); | |
for (int j=0;j<SZ(P)&&i*P[j]<PMAX;++j){ | |
isP[i*P[j]]=1; if (!(i%P[j])) break; | |
} | |
} | |
} | |
*/ | |
/* | |
inline int phi(int n){ | |
int res = n; for (int i=2;sqr(i)<=n;++i) if (!(n%i)){ | |
DEC(res, qtt(res, i)); | |
do{n /= i;} while(!(n%i)); | |
} | |
if (n != 1) | |
DEC(res, qtt(res, n)); | |
return res; | |
} | |
*/ | |
/*LL d, x, y; void exGcd(LL a, LL b){ | |
if(!b) x = 1, y = 0, d = a; | |
else{ | |
exGcd(b, a%b); LL t = y; | |
y = x - (a/b)*y, x = t; | |
} | |
}*/ | |
} using namespace NT;//} | |
// <<= '9. Comutational Geometry .,//{ | |
namespace CG{ | |
#define cPo const Po& | |
#define cLine const Line& | |
#define cSeg const Seg& | |
inline DB dist2(DB x,DB y){return sqr(x)+sqr(y);} | |
struct Po{ | |
DB x,y;Po(DB x=0,DB y=0):x(x),y(y){} | |
void in(){RF(x,y);}void out(){printf("(%.2f,%.2f)",x,y);} | |
inline friend istream&operator>>(istream&i,Po&p){return i>>p.x>>p.y;} | |
inline friend ostream&operator<<(ostream&o,Po p){return o<<"("<<p.x<<", "<<p.y<< ")";} | |
Po operator-()const{return Po(-x,-y);} | |
Po&operator+=(cPo p){x+=p.x,y+=p.y;rTs;}Po&operator-=(cPo p){x-=p.x,y-=p.y;rTs;} | |
Po&operator*=(DB k){x*=k,y*=k;rTs;}Po&operator/=(DB k){x/=k,y/=k;rTs;} | |
Po&operator*=(cPo p){rTs=Ts*p;}Po&operator/=(cPo p){rTs=Ts/p;} | |
Po operator+(cPo p)const{return Po(x+p.x,y+p.y);}Po operator-(cPo p)const{return Po(x-p.x,y-p.y);} | |
Po operator*(DB k)const{return Po(x*k,y*k);}Po operator/(DB k)const{return Po(x/k,y/k);} | |
Po operator*(cPo p)const{return Po(x*p.x-y*p.y,y*p.x+x*p.y);}Po operator/(cPo p)const{return Po(x*p.x+y*p.y,y*p.x-x*p.y)/p.len2();} | |
bool operator==(cPo p)const{return!sgn(x,p.x)&&!sgn(y,p.y);};bool operator!=(cPo p)const{return sgn(x,p.x)||sgn(y,p.y);} | |
bool operator<(cPo p)const{return sgn(x,p.x)<0||!sgn(x,p.x)&&sgn(y,p.y)<0;}bool operator<=(cPo p)const{return sgn(x,p.x)<0||!sgn(x,p.x)&&sgn(y,p.y)<=0;} | |
bool operator>(cPo p)const{return!(Ts<=p);}bool operator >=(cPo p)const{return!(Ts<p);} | |
DB len2()const{return dist2(x,y);}DB len()const{return sqrt(len2());}DB arg()const{return atan2(y,x);} | |
Po&_1(){rTs/=len();}Po&conj(){y=-y;rTs;}Po<(){swap(x,y),x=-x;rTs;}Po&rt(){swap(x,y),y=-y;rTs;} | |
Po&rot(DB a,cPo o=Po()){Ts-=o;Ts*=Po(cos(a),sin(a));rTs+=o;} | |
}; | |
inline DB dot(DB x1,DB y1,DB x2,DB y2){return x1*x2+y1*y2;} | |
inline DB dot(cPo a,cPo b){return dot(a.x,a.y,b.x,b.y);} | |
inline DB dot(cPo p0,cPo p1,cPo p2){return dot(p1-p0,p2-p0);} | |
inline DB det(DB x1,DB y1,DB x2,DB y2){return x1*y2-x2*y1;} | |
inline DB det(cPo a,cPo b){return det(a.x,a.y,b.x,b.y);} | |
inline DB det(cPo p0,cPo p1,cPo p2){return det(p1-p0,p2-p0);} | |
inline DB ang(cPo p0,cPo p1){return acos(dot(p0,p1)/p0.len()/p1.len());} | |
inline DB ang(cPo p0,cPo p1,cPo p2){return ang(p1-p0,p2-p0);} | |
inline DB ang(cPo p0,cPo p1,cPo p2,cPo p3){return ang(p1-p0,p3-p2);} | |
inline DB dist2(const Po &a, const Po &b){return dist2(a.x-b.x, a.y-b.y);} | |
template<class T1, class T2> inline int dett(const T1 &x, const T2 &y){return sgn(det(x, y));} | |
template<class T1, class T2, class T3> inline int dett(const T1 &x, const T2 &y, const T3 &z){return sgn(det(x, y, z));} | |
template<class T1, class T2, class T3, class T4> inline int dett(const T1 &x, const T2 &y, const T3 &z, const T4 &w){return sgn(det(x, y, z, w));} | |
template<class T1, class T2> inline int dott(const T1 &x, const T2 &y){return sgn(dot(x, y));} | |
template<class T1, class T2, class T3> inline int dott(const T1 &x, const T2 &y, const T3 &z){return sgn(dot(x, y, z));} | |
template<class T1, class T2, class T3, class T4> inline int dott(const T1 &x, const T2 &y, const T3 &z, const T4 &w){return sgn(dot(x, y, z, w));} | |
template<class T1, class T2> inline DB arg(const T1 &x, const T2 &y){DB a=ang(x,y);return~dett(x,y)?a:2*PI-a;} | |
template<class T1, class T2, class T3> inline DB arg(const T1 &x, const T2 &y, const T3 &z){DB a=ang(x,y,z);return~dett(x,y,z)?a:2*PI-a;} | |
template<class T1, class T2, class T3, class T4> inline DB arg(const T1 &x, const T2 &y, const T3 &z, const T4 &w){DB a=ang(x,y,z,w);return~dett(x,y,z,w)?a:2*PI-a;} | |
template<class T1, class T2> inline DB dist(const T1 &x, const T2 &y){return sqrt(dist2(x, y));} | |
template<class T1, class T2, class T3> inline DB dist(const T1 &x, const T2 &y, const T3 &z){return sqrt(dist2(x, y, z));} | |
inline Po _1(Po p){return p._1();}inline Po conj(Po p){return p.conj();} | |
inline Po lt(Po p){return p.lt();}inline Po rt(Po p){return p.rt();} | |
inline Po rot(Po p,DB a,cPo o=Po()){return p.rot(a,o);} | |
inline Po operator *(DB k,cPo p){return p*k;} | |
inline Po operator /(DB k,cPo p){return conj(p)*k/p.len2();} | |
typedef vector<Po> VP; | |
struct Line{ | |
Po a,b;Line(cPo a=Po(),cPo b=Po()):a(a),b(b){} | |
Line(DB x0,DB y0,DB x1,DB y1):a(Po(x0,y0)),b(Po(x1,y1)){} | |
Line(cLine l):a(l.a),b(l.b){} | |
//Ax+By+C=0 | |
Line(DB A,DB B,DB C){ | |
C=-C;if(!::sgn(A))a=Po(0,C/B),b=Po(1,C/B); | |
else if(!::sgn(B))a=Po(C/A,0),b=Po(C/A,1); | |
else a=Po(0,C/B),b=Po(1,(C-A)/B); | |
} | |
void in(){a.in(),b.in();} | |
inline friend istream&operator>>(istream&i,Line& p){return i>>p.a>>p.b;} | |
inline friend ostream&operator<<(ostream&o,Line p){return o<<p.a<<"-"<< p.b;} | |
Line operator+(cPo x)const{return Line(a+x,b+x);} | |
Line operator-(cPo x)const{return Line(a-x,b-x);} | |
Line operator*(DB k)const{return Line(a*k,b*k);} | |
Line operator/(DB k)const{return Line(a/k,b/k);} | |
Po operator*(cLine)const; | |
Po d()const{return b-a;}DB len2()const{return d().len2();}DB len()const{return d().len();}DB arg()const{return d().arg();} | |
int sgn(cPo p)const{return dett(a, b, p);} | |
int sgn(cLine)const; | |
bool sameSgn(cPo p1,cPo p2)const{return sgn(p1)==sgn(p2);} | |
void getEquation(DB&K,DB&B)const{ | |
K = ::sgn(a.x, b.x) ? (b.y-a.y)/(b.x-a.x) : OO; | |
B = a.y - K*a.x; | |
} | |
void getEquation(DB&A,DB&B,DB&C)const{A=a.y-b.y,B=b.x-a.x,C=det(a, b);} | |
Line&push(DB r){ // 正数右手螺旋向里 | |
Po v=d()._1().lt()*r;a+=v,b+=v; rTs; | |
} | |
}; | |
inline DB dot(cLine l1,cLine l2){return dot(l1.d(),l2.d());} | |
inline DB dot(cLine l,cPo p){return dot(l.a,l.b,p);} | |
inline DB dot(cPo p,cLine l){return dot(p,l.a,l.b);} | |
inline DB det(cLine l1,cLine l2){return det(l1.d(),l2.d());} | |
inline DB det(cLine l,cPo p){return det(l.a,l.b,p);} | |
inline DB det(cPo p,cLine l){return det(p,l.a,l.b);} | |
inline DB ang(cLine l0,cLine l1){return ang(l0.d(),l1.d());} | |
inline DB ang(cLine l,cPo p){return ang(l.a,l.b,p);} | |
inline DB ang(cPo p,cLine l){return ang(p,l.a,l.b);} | |
inline int Line::sgn(cLine l)const{return dett(Ts, l);} | |
inline Po Line::operator*(cLine l)const{return a+d()*det(a,l)/det(Ts,l);} | |
inline Po operator&(cPo p,cLine l){return l*Line(p,p+l.d().lt());} | |
inline Po operator%(cPo p,cLine l){return p&l*2-p;} | |
inline Line push(Line l, DB r){return l.push(r);} | |
struct Seg: public Line{ | |
Seg(cPo a=Po(),cPo b=Po()):Line(a,b){} | |
Seg(DB x0,DB y0,DB x1,DB y1):Line(x0,y0,x1,y1){} | |
Seg(cLine l):Line(l){} | |
Seg(const Po &a,DB alpha):Line(a,alpha){} | |
Seg(DB A,DB B,DB C):Line(A,B,C){} | |
inline int sgn(cPo p)const; | |
inline int sgn(cLine l)const; | |
inline bool qrt(cSeg l)const; | |
inline int sgn(cSeg l)const; | |
}; | |
// -1不相交 0相交(不规范) 1相交(规范) | |
inline int Seg::sgn(cPo p)const{return -dott(p,a,b);} | |
inline int Seg::sgn(cLine l)const{return sgn(Ts*l);} | |
// quick_rejection_test | |
inline bool Seg::qrt(cSeg l)const{ | |
return min(a.x,b.x)<=max(l.a.x,l.b.x)&&min(l.a.x,l.b.x)<=max(a.x,b.x)&& | |
min(a.y,b.y)<=max(l.a.y,l.b.y)&&min(l.a.y,l.b.y)<=max(a.y,b.y); | |
} | |
inline int Seg::sgn(cSeg l)const{ | |
if (!qrt(l)) return -1; | |
/*return | |
(dett(a,b,l.a)*dett(a,b,l.b)<=0 && | |
dett(l.a,l.b,a)*dett(l.a,l.b,b)<=0)?1:-1;*/ | |
int d1=dett(a,b,l.a),d2=dett(a,b,l.b),d3=dett(l.a,l.b,a),d4=dett(l.a,l.b,b); | |
if ((d1^d2)==-2&&(d3^d4)==-2)return 1; | |
return ((!d1&&dott(l.a-a,l.a-b)<=0)||(!d2&&dott(l.b-a,l.b-b)<=0)|| | |
(!d3&&dott(a-l.a,a-l.b)<=0)||(!d4&&dott(b-l.a,b-l.b)<=0))?0:-1; | |
} | |
//inline DB dist2(cLine l,cPo p){return sqr(fabs(dot(lt(l.d()), p-l.a)))/l.len2();} | |
inline DB dist2(cLine l,cPo p){return sqr(fabs(det(l.d(), p-l.a)))/l.len2();} | |
inline DB dist2(cLine l1,cLine l2){return dett(l1,l2)?0:dist2(l1,l2.a);} | |
inline DB dist2(cSeg l,cPo p){ | |
Po pa = p - l.a, pb = p - l.b; | |
if (dott(l.d(), pa) <= 0) return pa.len2(); | |
if (dott(l.d(), pb) >= 0) return pb.len2(); | |
return dist2(Line(l), p); | |
} | |
inline DB dist2(cSeg s,cLine l){ | |
Po v1=s.a-l.a,v2=s.b-l.a;DB d1=det(l.d(),v1),d2=det(l.d(),v2); | |
return sgn(d1)!=sgn(d2) ? 0 : sqr(min(fabs(d1), fabs(d2)))/l.len2(); | |
} | |
inline DB dist2(cSeg l1,cSeg l2){ | |
if (~l1.sgn(l2)) return 0; | |
else return min(dist2(l2,l1.a), dist2(l2,l1.b), dist2(l1,l2.a), dist2(l1,l2.b)); | |
} | |
template<class T1, class T2> inline DB dist2(const T1& a, const T2& b){ | |
return dist2(b, a); | |
} | |
Po getPo(){Po p;p.in();return p;} | |
Line getLine(){Line l;l.in();return l;} | |
DB getArea(const VP& P){DB z=0;FOR(i,1,SZ(P))z+=det(P[i-1],P[i]);return z;} | |
DB getPeri(const VP& P){DB z=0;FOR(i,1,SZ(P))z+=dist(P[i-1],P[i]);return z;} | |
} using namespace CG;//} | |
//} | |
/** I/O Accelerator Interface .. **/ //{ | |
#define g (c=getchar()) | |
#define d isdigit(g) | |
#define p x=x*10+c-'0' | |
#define n x=x*10+'0'-c | |
#define pp l/=10,p | |
#define nn l/=10,n | |
template<class T> inline T& RD(T &x){ | |
char c;while(!d);x=c-'0';while(d)p; | |
return x; | |
} | |
template<class T> inline T& RDD(T &x){ | |
char c;while(g,c!='-'&&!isdigit(c)); | |
if (c=='-'){x='0'-g;while(d)n;} | |
else{x=c-'0';while(d)p;} | |
return x; | |
} | |
inline DB& RF(DB &x){ | |
//scanf("%lf", &x); | |
char c;while(g,c!='-'&&c!='.'&&!isdigit(c)); | |
if(c=='-')if(g=='.'){x=0;DB l=1;while(d)nn;x*=l;} | |
else{x='0'-c;while(d)n;if(c=='.'){DB l=1;while(d)nn;x*=l;}} | |
else if(c=='.'){x=0;DB l=1;while(d)pp;x*=l;} | |
else{x=c-'0';while(d)p;if(c=='.'){DB l=1;while(d)pp;x*=l;}} | |
return x; | |
} | |
#undef nn | |
#undef pp | |
#undef n | |
#undef p | |
#undef d | |
#undef g | |
inline char* RS(char *s){ | |
//gets(s); | |
scanf("%s", s); | |
return s; | |
} | |
LL last_ans; int Case; template<class T> inline void OT(const T &x){ | |
//printf("Case #%d: ", ++Case); | |
//printf("%lld\n", x); | |
//printf("%.9f\n", x); | |
printf("%d\n", x); | |
//cout << x << endl; | |
//last_ans = x; | |
} | |
//} | |
//}/* .................................................................................................................................. */ | |
const int N = int(1e5) + 9; | |
char str[N]; uint S[N], A[N]; | |
int n, m, l; | |
namespace SHash{ // 1-offset | |
const int Z = 27; | |
uint P[N]; | |
int h(uint S[], int l, int r){ | |
--l; return S[r]-S[l]*P[r-l]; | |
} | |
void init(){ | |
P[0] = 1; FOR(i, 1, N) P[i] = P[i-1] * Z; | |
} | |
void init(char str[], int n, uint S[]){ | |
REP_1(i, n) S[i] = S[i-1]*Z + (str[i]-'a'+1); | |
} | |
} using namespace SHash; | |
int main(){ | |
#ifndef ONLINE_JUDGE | |
freopen("in.txt", "r", stdin); | |
//freopen("out.txt", "w", stdout); | |
#endif | |
init(); while (~scanf("%d%d", &m, &l)){ | |
n = strlen(RS(str+1)); init(str, n, S); | |
int res = 0; REP_1(o, l){ | |
int ll = 0; set<uint> H; REP_1(i, n){ | |
if (o+i*l-1 > n) break; A[i] = h(S, o+(i-1)*l, o+i*l-1); | |
while (CTN(H, A[i])) H.erase(A[++ll]); H.insert(A[i]); | |
if (i-ll == m) ++res, H.erase(A[++ll]); | |
} | |
} | |
OT(res); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** Micro Mezz Macro Flation -- Overheated Economy ., Last Update: May. 7th 2014 **/ //{ | |
/** Header .. **/ //{ | |
#pragma comment(linker, "/STACK:36777216") | |
//#pragma GCC optimize ("O2") | |
#define LOCAL | |
//#include "testlib.h" | |
#include <functional> | |
#include <algorithm> | |
#include <iostream> | |
#include <fstream> | |
#include <sstream> | |
#include <iomanip> | |
#include <numeric> | |
#include <cstring> | |
#include <climits> | |
#include <cassert> | |
#include <complex> | |
#include <cstdio> | |
#include <string> | |
#include <vector> | |
#include <bitset> | |
#include <queue> | |
#include <stack> | |
#include <cmath> | |
#include <ctime> | |
#include <list> | |
#include <set> | |
#include <map> | |
//#include <tr1/unordered_set> | |
//#include <tr1/unordered_map> | |
//#include <array> | |
using namespace std; | |
#define REP(i, n) for (int i=0;i<n;++i) | |
#define FOR(i, a, b) for (int i=a;i<b;++i) | |
#define DWN(i, b, a) for (int i=b-1;i>=a;--i) | |
#define REP_1(i, n) for (int i=1;i<=n;++i) | |
#define FOR_1(i, a, b) for (int i=a;i<=b;++i) | |
#define DWN_1(i, b, a) for (int i=b;i>=a;--i) | |
#define REP_C(i, n) for (int n____=n,i=0;i<n____;++i) | |
#define FOR_C(i, a, b) for (int b____=b,i=a;i<b____;++i) | |
#define DWN_C(i, b, a) for (int a____=a,i=b-1;i>=a____;--i) | |
#define REP_N(i, n) for (i=0;i<n;++i) | |
#define FOR_N(i, a, b) for (i=a;i<b;++i) | |
#define DWN_N(i, b, a) for (i=b-1;i>=a;--i) | |
#define REP_1_C(i, n) for (int n____=n,i=1;i<=n____;++i) | |
#define FOR_1_C(i, a, b) for (int b____=b,i=a;i<=b____;++i) | |
#define DWN_1_C(i, b, a) for (int a____=a,i=b;i>=a____;--i) | |
#define REP_1_N(i, n) for (i=1;i<=n;++i) | |
#define FOR_1_N(i, a, b) for (i=a;i<=b;++i) | |
#define DWN_1_N(i, b, a) for (i=b;i>=a;--i) | |
#define REP_C_N(i, n) for (int n____=(i=0,n);i<n____;++i) | |
#define FOR_C_N(i, a, b) for (int b____=(i=0,b);i<b____;++i) | |
#define DWN_C_N(i, b, a) for (int a____=(i=b-1,a);i>=a____;--i) | |
#define REP_1_C_N(i, n) for (int n____=(i=1,n);i<=n____;++i) | |
#define FOR_1_C_N(i, a, b) for (int b____=(i=a,b);i<=b____;++i) | |
#define DWN_1_C_N(i, b, a) for (int a____=(i=b,a);i>=a____;--i) | |
#define ECH(it, A) for (__typeof(A.begin()) it=A.begin(); it != A.end(); ++it) | |
#define REP_S(i, str) for (char*i=str;*i;++i) | |
#define REP_L(i, hd, suc) for (int i=hd;i;i=suc[i]) | |
#define REP_G(i, u) REP_L(i,hd[u],suc) | |
#define REP_SS(x, s) for (int x=s;x;x=(x-1)&s) | |
#define DO(n) for ( int ____n = n; ____n-->0; ) | |
#define REP_2(i, j, n, m) REP(i, n) REP(j, m) | |
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m) | |
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l) | |
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l) | |
#define REP_4(i, j, k, ii, n, m, l, nn) REP(i, n) REP(j, m) REP(k, l) REP(ii, nn) | |
#define REP_4_1(i, j, k, ii, n, m, l, nn) REP_1(i, n) REP_1(j, m) REP_1(k, l) REP_1(ii, nn) | |
#define ALL(A) A.begin(), A.end() | |
#define LLA(A) A.rbegin(), A.rend() | |
#define CPY(A, B) memcpy(A, B, sizeof(A)) | |
#define INS(A, P, B) A.insert(A.begin() + P, B) | |
#define ERS(A, P) A.erase(A.begin() + P) | |
#define LBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define UBD(A, x) (lower_bound(ALL(A), x) - A.begin()) | |
#define CTN(T, x) (T.find(x) != T.end()) | |
#define SZ(A) int((A).size()) | |
#define PB push_back | |
#define MP(A, B) make_pair(A, B) | |
#define PTT pair<T, T> | |
#define Ts *this | |
#define rTs return Ts | |
#define fi first | |
#define se second | |
#define re real() | |
#define im imag() | |
#define Rush for(int ____T=RD(); ____T--;) | |
#define Display(A, n, m) { \ | |
REP(i, n){ \ | |
REP(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m-1] << endl; \ | |
} \ | |
} | |
#define Display_1(A, n, m) { \ | |
REP_1(i, n){ \ | |
REP_1(j, m-1) cout << A[i][j] << " "; \ | |
cout << A[i][m] << endl; \ | |
} \ | |
} | |
typedef long long LL; | |
//typedef long double DB; | |
typedef double DB; | |
typedef unsigned uint; | |
typedef unsigned long long uLL; | |
typedef vector<int> VI; | |
typedef vector<char> VC; | |
typedef vector<string> VS; | |
typedef vector<LL> VL; | |
typedef vector<DB> VF; | |
typedef set<int> SI; | |
typedef set<string> SS; | |
typedef map<int, int> MII; | |
typedef map<string, int> MSI; | |
typedef pair<int, int> PII; | |
typedef pair<LL, LL> PLL; | |
typedef vector<PII> VII; | |
typedef vector<VI> VVI; | |
typedef vector<VII> VVII; | |
template<class T> inline T& RD(T &); | |
template<class T> inline void OT(const T &); | |
//inline int RD(){int x; return RD(x);} | |
inline LL RD(){LL x; return RD(x);} | |
inline DB& RF(DB &); | |
inline DB RF(){DB x; return RF(x);} | |
inline char* RS(char *s); | |
inline char& RC(char &c); | |
inline char RC(); | |
inline char& RC(char &c){scanf(" %c", &c); return c;} | |
inline char RC(){char c; return RC(c);} | |
//inline char& RC(char &c){c = getchar(); return c;} | |
//inline char RC(){return getchar();} | |
template<class T> inline T& RDD(T &); | |
inline LL RDD(){LL x; return RDD(x);} | |
template<class T0, class T1> inline T0& RD(T0 &x0, T1 &x1){RD(x0), RD(x1); return x0;} | |
template<class T0, class T1, class T2> inline T0& RD(T0 &x0, T1 &x1, T2 &x2){RD(x0), RD(x1), RD(x2); return x0;} | |
template<class T0, class T1, class T2, class T3> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3){RD(x0), RD(x1), RD(x2), RD(x3); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); return x0;} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); return x0;} | |
template<class T0, class T1> inline void OT(const T0 &x0, const T1 &x1){OT(x0), OT(x1);} | |
template<class T0, class T1, class T2> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2){OT(x0), OT(x1), OT(x2);} | |
template<class T0, class T1, class T2, class T3> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3){OT(x0), OT(x1), OT(x2), OT(x3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5, const T6 &x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);} | |
inline char& RC(char &a, char &b){RC(a), RC(b); return a;} | |
inline char& RC(char &a, char &b, char &c){RC(a), RC(b), RC(c); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d){RC(a), RC(b), RC(c), RC(d); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e){RC(a), RC(b), RC(c), RC(d), RC(e); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f); return a;} | |
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g); return a;} | |
inline DB& RF(DB &a, DB &b){RF(a), RF(b); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c){RF(a), RF(b), RF(c); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d){RF(a), RF(b), RF(c), RF(d); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e){RF(a), RF(b), RF(c), RF(d), RF(e); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f); return a;} | |
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f, DB &g){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g); return a;} | |
inline void RS(char *s1, char *s2){RS(s1), RS(s2);} | |
inline void RS(char *s1, char *s2, char *s3){RS(s1), RS(s2), RS(s3);} | |
template<class T0,class T1>inline void RDD(T0&a, T1&b){RDD(a),RDD(b);} | |
template<class T0,class T1,class T2>inline void RDD(T0&a, T1&b, T2&c){RDD(a),RDD(b),RDD(c);} | |
template<class T> inline void RST(T &A){memset(A, 0, sizeof(A));} | |
template<class T> inline void FLC(T &A, int x){memset(A, x, sizeof(A));} | |
template<class T> inline void CLR(T &A){A.clear();} | |
template<class T0, class T1> inline void RST(T0 &A0, T1 &A1){RST(A0), RST(A1);} | |
template<class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2){RST(A0), RST(A1), RST(A2);} | |
template<class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3){RST(A0), RST(A1), RST(A2), RST(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);} | |
template<class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x){FLC(A0, x), FLC(A1, x);} | |
template<class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x);} | |
template<class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x), FLC(A6, x);} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, less<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q){while (!Q.empty()) Q.pop();} | |
template<class T> inline void CLR(stack<T> &S){while (!S.empty()) S.pop();} | |
template<class T0, class T1> inline void CLR(T0 &A0, T1 &A1){CLR(A0), CLR(A1);} | |
template<class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2){CLR(A0), CLR(A1), CLR(A2);} | |
template<class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);} | |
template<class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);} | |
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);} | |
template<class T> inline void CLR(T &A, int n){REP(i, n) CLR(A[i]);} | |
template<class T> inline bool EPT(T &a){return a.empty();} | |
template<class T> inline T& SRT(T &A){sort(ALL(A)); return A;} | |
template<class T, class C> inline T& SRT(T &A, C B){sort(ALL(A), B); return A;} | |
template<class T> inline T& RVS(T &A){reverse(ALL(A)); return A;} | |
template<class T> inline T& UNQQ(T &A){A.resize(unique(ALL(A))-A.begin());return A;} | |
template<class T> inline T& UNQ(T &A){SRT(A);return UNQQ(A);} | |
//} | |
/** Constant List .. **/ //{ | |
const int MOD = int(1e9) + 7; | |
const int INF = 0x3f3f3f3f; | |
const LL INFF = 0x3f3f3f3f3f3f3f3fLL; | |
const DB EPS = 1e-9; | |
const DB OO = 1e20; | |
const DB PI = acos(-1.0); //M_PI; | |
const int dx[] = {-1, 0, 1, 0}; | |
const int dy[] = {0, 1, 0, -1}; | |
//} | |
/** Add On .. **/ //{ | |
// <<= '0. Nichi Joo ., //{ | |
template<class T> inline T& checkMin(T &a,const T b){if (b<a) a=b;return a;} | |
template<class T> inline T& checkMax(T &a,const T b){if (a<b) a=b;return a;} | |
template<class T> inline T& checkMin(T &a, T &b, const T x){checkMin(a, x), checkMin(b, x);return a;} | |
template<class T> inline T& checkMax(T &a, T &b, const T x){checkMax(a, x), checkMax(b, x);return a;} | |
template <class T, class C> inline T& checkMin(T& a, const T b, C c){if (c(b,a)) a = b;return a;} | |
template <class T, class C> inline T& checkMax(T& a, const T b, C c){if (c(a,b)) a = b;return a;} | |
template<class T> inline T min(T a, T b, T c){return min(min(a, b), c);} | |
template<class T> inline T max(T a, T b, T c){return max(max(a, b), c);} | |
template<class T> inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));} | |
template<class T> inline T max(T a, T b, T c, T d){return max(max(a, b), max(c, d));} | |
template<class T> inline T min(T a, T b, T c, T d, T e){return min(min(min(a,b),min(c,d)),e);} | |
template<class T> inline T max(T a, T b, T c, T d, T e){return max(max(max(a,b),max(c,d)),e);} | |
template<class T> inline T sqr(T a){return a*a;} | |
template<class T> inline T cub(T a){return a*a*a;} | |
template<class T> inline T ceil(T x, T y){return (x - 1) / y + 1;} | |
template<class T> T abs(T x){return x>0?x:-x;} | |
inline int sgn(DB x){return x < -EPS ? -1 : x > EPS;} | |
inline int sgn(DB x, DB y){return sgn(x - y);} | |
inline DB cos(DB a, DB b, DB c){return (sqr(a)+sqr(b)-sqr(c))/(2*a*b);} | |
inline DB cot(DB x){return 1./tan(x);}; | |
inline DB sec(DB x){return 1./cos(x);}; | |
inline DB csc(DB x){return 1./sin(x);}; | |
//} | |
// <<= '1. Bitwise Operation ., //{ | |
namespace BO{ | |
inline bool _1(int x, int i){return bool(x&1<<i);} | |
inline bool _1(LL x, int i){return bool(x&1LL<<i);} | |
inline LL _1(int i){return 1LL<<i;} | |
inline LL _U(int i){return _1(i) - 1;}; | |
inline int reverse_bits(int x){ | |
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa); | |
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc); | |
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0); | |
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00); | |
x = ((x >>16) & 0x0000ffff) | ((x <<16) & 0xffff0000); | |
return x; | |
} | |
inline LL reverse_bits(LL x){ | |
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL); | |
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL); | |
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL); | |
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL); | |
x = ((x >>16) & 0x0000ffff0000ffffLL) | ((x <<16) & 0xffff0000ffff0000LL); | |
x = ((x >>32) & 0x00000000ffffffffLL) | ((x <<32) & 0xffffffff00000000LL); | |
return x; | |
} | |
template<class T> inline bool odd(T x){return x&1;} | |
template<class T> inline bool even(T x){return !odd(x);} | |
template<class T> inline T low_bit(T x) {return x & -x;} | |
template<class T> inline T high_bit(T x) {T p = low_bit(x);while (p != x) x -= p, p = low_bit(x);return p;} | |
template<class T> inline T cover_bit(T x){T p = 1; while (p < x) p <<= 1;return p;} | |
template<class T> inline int cover_idx(T x){int p = 0; while (_1(p) < x ) ++p; return p;} | |
inline int clz(int x){return __builtin_clz(x);} | |
inline int clz(LL x){return __builtin_clzll(x);} | |
inline int ctz(int x){return __builtin_ctz(x);} | |
inline int ctz(LL x){return __builtin_ctzll(x);} | |
inline int lg2(int x){return !x ? -1 : 31 - clz(x);} | |
inline int lg2(LL x){return !x ? -1 : 63 - clz(x);} | |
inline int low_idx(int x){return !x ? -1 : ctz(x);} | |
inline int low_idx(LL x){return !x ? -1 : ctz(x);} | |
inline int high_idx(int x){return lg2(x);} | |
inline int high_idx(LL x){return lg2(x);} | |
inline int parity(int x){return __builtin_parity(x);} | |
inline int parity(LL x){return __builtin_parityll(x);} | |
inline int count_bits(int x){return __builtin_popcount(x);} | |
inline int count_bits(LL x){return __builtin_popcountll(x);} | |
} using namespace BO;//} | |
// <<= '2. Number Theory .,//{ | |
namespace NT{ | |
inline LL gcd(LL a, LL b){return __gcd(a, b);} | |
inline LL lcm(LL a, LL b){return a*b/gcd(a,b);} | |
inline void INC(int &a, int b){a += b; if (a >= MOD) a -= MOD;} | |
inline int sum(int a, int b){a += b; if (a >= MOD) a -= MOD; return a;} | |
inline void DEC(int &a, int b){a -= b; if (a < 0) a += MOD;} | |
inline int dff(int a, int b){a -= b; if (a < 0) a += MOD; return a;} | |
inline void MUL(int &a, int b){a = (LL)a * b % MOD;} | |
inline int pdt(int a, int b){return (LL)a * b % MOD;} | |
inline int gcd(int m, int n, int &x, int &y){ | |
x = 1, y = 0; int xx = 0, yy = 1, q; | |
while (1){ | |
q = m / n, m %= n; | |
if (!m){x = xx, y = yy; return n;} | |
DEC(x, pdt(q, xx)), DEC(y, pdt(q, yy)); | |
q = n / m, n %= m; | |
if (!n) return m; | |
DEC(xx, pdt(q, x)), DEC(yy, pdt(q, y)); | |
} | |
} | |
inline int sum(int a, int b, int c){return sum(a, sum(b, c));} | |
inline int sum(int a, int b, int c, int d){return sum(sum(a, b), sum(c, d));} | |
inline int pdt(int a, int b, int c){return pdt(a, pdt(b, c));} | |
inline int pdt(int a, int b, int c, int d){return pdt(pdt(a, b), pdt(c, d));} | |
inline int pow(int a, LL b){ | |
int c(1); while (b){ | |
if (b&1) MUL(c, a); | |
MUL(a, a), b >>= 1; | |
} | |
return c; | |
} | |
template<class T> inline T pow(T a, LL b){ | |
T c(1); while (b){ | |
if (b&1) c *= a; | |
a *= a, b >>= 1; | |
} | |
return c; | |
} | |
template<class T> inline T pow(T a, int b){ | |
return pow(a, (LL)b); | |
} | |
inline int _I(int b){ | |
int a = MOD, x1 = 0, x2 = 1, q; | |
while (true){ | |
q = a / b, a %= b; | |
if (!a) return (x2 + MOD) % MOD; | |
DEC(x1, pdt(q, x2)); | |
q = b / a, b %= a; | |
if (!b) return (x1 + MOD) % MOD; | |
DEC(x2, pdt(q, x1)); | |
} | |
} | |
inline void DIV(int &a, int b){MUL(a, _I(b));} | |
inline int qtt(int a, int b){return pdt(a, _I(b));} | |
struct Int{ | |
int val; | |
operator int() const{return val;} | |
Int(int val = 0):val(val){ | |
val %= MOD; if (val < 0) val += MOD; | |
} | |
Int(LL _val){ | |
_val %= MOD; if (_val < 0) _val += MOD; | |
val = _val; | |
} | |
Int& operator +=(const int& rhs){ | |
INC(val, rhs); | |
return *this; | |
} | |
Int operator +(const int& rhs) const{ | |
return sum(val, rhs); | |
} | |
Int& operator -=(const int& rhs){ | |
DEC(val, rhs); | |
return *this; | |
} | |
Int operator -(const int& rhs) const{ | |
return dff(val, rhs); | |
} | |
Int& operator *=(const int& rhs){ | |
MUL(val, rhs); | |
return *this; | |
} | |
Int operator *(const int& rhs) const{ | |
return pdt(val, rhs); | |
} | |
Int& operator /=(const int& rhs){ | |
DIV(val, rhs); | |
return *this; | |
} | |
Int operator /(const int& rhs) const{ | |
return qtt(val, rhs); | |
} | |
Int operator-()const{ | |
return MOD-*this; | |
} | |
}; | |
/* | |
Int Fact[N], Factt[N]; Int Binom(int n, int m){ | |
return Fact[n] * Factt[m] * Factt[n-m]; | |
} | |
*/ | |
/* | |
Fact[0] = 1; REP_1(i, N-1) Fact[i] = Fact[i-1] * i; | |
Factt[N-1] = _I(Fact[N-1]); DWN(i, N, 1) Factt[i-1] = Factt[i] * i; | |
*/ | |
/* | |
int Binom[N][N]; | |
REP(i, N){Binom[i][0] = 1; REP_1(j, i) Binom[i][j] = Binom[i-1][j-1] + Binom[i-1][j];} | |
*/ | |
/* | |
const int PMAX = 1; | |
VI P; bitset<PMAX> isP; | |
void sieve(){ | |
FOR(i, 2, PMAX){ | |
if (!isP[i]) P.PB(i); | |
for (int j=0;j<SZ(P)&&i*P[j]<PMAX;++j){ | |
isP[i*P[j]]=1; if (!(i%P[j])) break; | |
} | |
} | |
} | |
*/ | |
/* | |
inline int phi(int n){ | |
int res = n; for (int i=2;sqr(i)<=n;++i) if (!(n%i)){ | |
DEC(res, qtt(res, i)); | |
do{n /= i;} while(!(n%i)); | |
} | |
if (n != 1) | |
DEC(res, qtt(res, n)); | |
return res; | |
} | |
*/ | |
/*LL d, x, y; void exGcd(LL a, LL b){ | |
if(!b) x = 1, y = 0, d = a; | |
else{ | |
exGcd(b, a%b); LL t = y; | |
y = x - (a/b)*y, x = t; | |
} | |
}*/ | |
} using namespace NT;//} | |