int recur(int r, int c){
if(r==1||c==1) return 0;
int k, sum=(r==c);
for(k=1; k<r || k<c; k++) {
if(r<=c){
if(k<r)
sum += recur(k, c) + recur(r-k, c);
else
sum += recur(r, k) + recur(r, c-k);
}else{
if(k<c)
sum += recur(r, k) + recur(r, c-k);
else
sum += recur(k, c) + recur(r-k, c);
}
}
return sum;
}
int main(){
int t, cur, i;
scanf("%d", &t);
while(t--){
scanf("%d", &len);
n = 0;
while(scanf("%d", &cur) && cur!=0) cars[n++] = cur/100.0;
memset(dp, -1, sizeof dp);
int res = recur(0, 0.0, 0.0);
printf("%d\n", res);
for(i = 0; i<res; i++){
printf("%s\n", (ports[i]==0)?"port":"starboard");
}
}
return 0;
}
int main()
{
recur(0, 1, 1, 2);
solve(1, 2);
std::cout << result << std::endl;
// for (int a = 1; a <= N; ++ a) {
// for (int b = a; a + b <= N; ++ b) {
// for (int c = b; c < a + b && a + b + c <= N; ++ c) {
// if ((long long)a * c % (a + b) == 0) {
// printf("%d, %d, %d\n", a, b, c);
// result --;
// }
// }
// }
// }
// assert(result == 0);
}
vector<int> inorderTraversal(TreeNode *root) {
#ifdef RECUR
std::vector<int> res;
recur(res, root);
return res;
#else
if(!root) return std::vector<int>();
std::vector<int> res;
std::stack<TreeNode*> s;
s.push(root);
TreeNode* prev = NULL;
// When curr is prev's child, the tree is been traversed downward
// When curr is prev's parent, the tree is been traversed upward
// Pre-order traversal requires pushing curr first, then prev
while(!s.empty()){
TreeNode* curr = s.top();
s.pop();
// Traverse down the tree
if(prev == NULL || (curr == prev->left) || (curr == prev->right)){
if(curr->right) s.push(curr->right);
if(curr->left){
s.push(curr);
s.push(curr->left);
}
else{
res.push_back(curr->val);
}
}
// Traverse up the tree
else{
res.push_back(curr->val);
}
prev = curr;
}
return res;
#endif
}
int recur(int n, int p)
{
f[n] = p;
if(n == 1)
{
strcat(&res[p], "((A0|B0)|(A0|B0))");
p += 17;
}
else
{
p += sprintf(&res[p], pre, n-1, n-1, n-1, n-1, n-1, n-1);
p = recur(n-1, p);
res[p] = res[p+1] = ')';
p += 2;
}
e[n] = p;
return p;
}
int main(){
int m, i,j,k, u,v,w;
while(scanf("%d", &n)>0){
if(n==0) return 0;
memset(g, -1, sizeof g);
scanf("%d", &m);
for(i=0; i<m; i++){
scanf("%d %d %d", &u, &v, &w);
u--;v--;
g[u][v]=w;
g[v][u]=w;
}
for(i=0; i<n; i++) dp[i]=-1;
memset(vis, 0, sizeof vis);
printf("%.6lf\n", recur(0)*100.0);
}
return 0;
}
inline bool recurToTarget(
Rewrite<Tuple> rw, const Tuple &target, CogPtr<Tuple> cog
){
{
switch(cog->type)
{
case COG_BTREE: {
BTreeCog<Tuple> *bc = ((BTreeCog<Tuple> *)cog.get());
bool ret = false;
if(target < bc->sep){ ret = ret || rw(bc->lhs); }
if(target > bc->sep){ ret = ret || rw(bc->rhs); }
return ret;
} break;
default:
return recur(rw, cog);
}
}
}
int main(){
int t,i,j,curV,maxV;
scanf("%d", &t);
while(t--){
memset(dp, -1, sizeof dp);
scanf("%d %d", &h, &w);
for(i=0; i<h; i++)
for(j=0; j<w; j++)
scanf("%d", &arr[i][j]);
maxV=0;
for(j=0; j<w; j++){
curV=recur(0,j);
if(curV>maxV)maxV=curV;
}
printf("%d\n", maxV);
}
return 0;
}
void recur(int pos, int mask) {
if (mask == 0) {
res++;
return;
}
for (int i = 0;; ++i) {
int bit = 1 << i;
if (bit > mask) {
break;
}
if (mask & bit) {
int a = i + 1;
int b = pos + 1;
if (a % b == 0 || b % a == 0) {
recur(pos + 1, mask & ~bit);
}
}
}
}
static void recur(const iodim *dims, int rnk, R *I)
{
if (rnk == RNK_MINFTY)
return;
else if (rnk == 0)
I[0] = K(0.0);
else if (rnk > 0) {
INT i, n = dims[0].n, is = dims[0].is;
if (rnk == 1) {
/* this case is redundant but faster */
for (i = 0; i < n; ++i)
I[i * is] = K(0.0);
} else {
for (i = 0; i < n; ++i)
recur(dims + 1, rnk - 1, I + i * is);
}
}
}
/* fill a complex array with zeros. */
static void recur(const iodim *dims, int rnk, R *ri, R *ii)
{
if (rnk == RNK_MINFTY)
return;
else if (rnk == 0)
ri[0] = ii[0] = K(0.0);
else if (rnk > 0) {
int i, n = dims[0].n;
int is = dims[0].is;
if (rnk == 1) {
/* this case is redundant but faster */
for (i = 0; i < n; ++i)
ri[i * is] = ii[i * is] = K(0.0);
} else {
for (i = 0; i < n; ++i)
recur(dims + 1, rnk - 1, ri + i * is, ii + i * is);
}
}
}
void recur(std::list<const CArea*> &arealist, const CArea* a1)
{
if(a1->m_curves.size() == 0)
return;
if(g_params.m_from_center)
arealist.push_front(a1);
else
arealist.push_back(a1);
CArea* a_offset = new CArea(*a1);
a_offset->Offset(g_params.m_step_over);
for(unsigned int i = 0; i<a_offset->m_curves.size(); i++)
{
CArea* a2 = new CArea();
a2->m_curves.push_back(a_offset->m_curves[i]);
recur(arealist, a2);
}
}
int main(){
int t, g, i, mw, c;
scanf("%d", &t);
while(t--){
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for(i=0; i<n; i++) scanf("%d %d", &P[i], &W[i]);
c = 0;
scanf("%d", &g);
for(i=0; i<g; i++) {
scanf("%d", &mw);
c += recur(0, mw);
}
printf("%d\n", c);
}
return 0;
}
int main() {
unsigned a, b;
CountMap[1u] = 1u;
while (std::cin >> a >> b) {
std::cout << a << " " << b << " ";
if (a > b)
std::swap(a, b);
unsigned Max = 0;
for (unsigned n = a; n <= b; ++n) {
unsigned Count = recur(n);
if (Count > Max)
Max = Count;
#ifndef ONLINE_JUDGE
std::cerr << "After " << n << ": Max = " << Max << std::endl;
#endif
}
std::cout << Max << "\n";
}
return 0;
}
int main(){
int t, V, i, a;
scanf("%d",&t);
while(t--){
scanf("%d %d", &V, &n);
memset(itemC, 0, sizeof itemC);
for(i=0; i<n; i++){
scanf("%d %d %d", &vol[i], &imp[i], &a);
a--;
isAtt[i]=0;
if(a>=0) {
isAtt[i]=1;
att[a][itemC[a]++]=i;
}
}
memset(dp, -1 , sizeof dp);
printf("%d\n", recur(0, V));
}
return 0;
}
int main(){
int i,j, kase=1, res;
while(scanf("%s", s)>0){
if(strcmp(s, "bye")==0) return 0;
n=strlen(s);
for(i=0; i<n; i++) {
for(j=i; j<n; j++){
if(i==j) sums[i][j] = s[i]-'0';
else sums[i][j] = sums[i][j-1]+(s[j]-'0');
}
}
res=1;
int arr[0];
for(i=1; i<n; i++) {
res+=recur(0, arr, 0,0, i);
}
printf("%d. %d\n", kase++, res);
}
return 0;
}
int main() {
while (1) {
read();
if (end()) break;
bool ans = 0;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j)
if (a[i][j] == '.') {
a[i][j] = 'x';
if (!recur('o')) {
print();
ans = 1;
break;
}
a[i][j] = '.';
}
if (ans) break;
}
}
return 0;
}
int main() {
int n;
int num;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &num);
for (int k = 0; k < 101; k++) {
for (int j = 0; j < 2; j++) {
arr[k][j] = -1;
}
}
printf("%d %d\n", recur(num), recur1(num));
}
}
int recur(int t, int sum){
if(t==N){
if(sum%N)
return 0;
return dp[t][sum] = 1;
}
if(dp[t][sum]!=-1)
return dp[t][sum];
int i;
for(i=0; i<n; i++){
if(!vis[i]){
vis[i] = 1;
if(recur(t+1, (sum+nums[i])%N)){
return dp[t][sum] = 1;
}else
vis[i] = 0;
}
}
return dp[t][sum] = 0;
}
static void recur(const iodim *dims, int rnk, R *I0, R *I1)
{
if (rnk == RNK_MINFTY)
return;
else if (rnk == 0)
I0[0] = K(0.0);
else if (rnk > 0) {
INT i, n = dims[0].n, is = dims[0].is;
if (rnk == 1) {
for (i = 0; i < n - 1; i += 2) {
*I0 = *I1 = K(0.0);
I0 += is; I1 += is;
}
if (i < n)
*I0 = K(0.0);
} else {
for (i = 0; i < n; ++i)
recur(dims + 1, rnk - 1, I0 + i * is, I1 + i * is);
}
}
}
static void recur(int rnk, const bench_iodim *dims0, const bench_iodim *dims1,
dotens2_closure *k,
int indx0, int ondx0, int indx1, int ondx1)
{
if (rnk == 0)
k->apply(k, indx0, ondx0, indx1, ondx1);
else {
int i, n = dims0[0].n;
int is0 = dims0[0].is;
int os0 = dims0[0].os;
int is1 = dims1[0].is;
int os1 = dims1[0].os;
BENCH_ASSERT(n == dims1[0].n);
for (i = 0; i < n; ++i) {
recur(rnk - 1, dims0 + 1, dims1 + 1, k,
indx0, ondx0, indx1, ondx1);
indx0 += is0; ondx0 += os0;
indx1 += is1; ondx1 += os1;
}
}
}
int main(int argc, char *argv[]) {
/* A stack allocated variable */
int i;
/* Dynamically allocate some stuff */
char *buf1 = (char*)malloc(100);
/* ... and some more stuff */
char *buf2 = (char*)malloc(100);
printf("_main @ %p\n", main);
printf("recur @ %p\n", recur);
/* TODO 2: Fix to get address of the stack variable */
printf("_main stack: %p\n", &i);
/* TODO 3: Fix to get address of a static variable */
printf("static data: %p\n", &stuff);
printf("Heap: malloc 1: %p\n", buf1);
printf("Heap: malloc 2: %p\n", buf2);
recur(3);
return 0;
}
int main(){
sieve();
int t,n,k, i,j,l, issqr,b,sqrc=0;
double sqrtb;
for(i=0; i<1050; i++) sqrs[i]=i*i;
for(i=0; i<1050; i++){
issqr=0;
for(j=1; sqrs[j]<primes[i]; j++){
sqrtb = sqrt(primes[i]-sqrs[j]);
if(fabs(sqrtb-(int)sqrtb)<EPS){ issqr=1; break; }
}
if(issqr) sqrprimes[sqrc++]=primes[i];
}
memset(dp, -1, sizeof dp);
scanf("%d", &t);
while(t--){
scanf("%d %d", &n, &k);
printf("%lld\n", recur(sqrprimes[n-1], k));
}
return 0;
}
int main(){
int t, i, j;
char c;
gets(sweet);
sscanf(sweet, "%d", &t);
while(t--){
gets(sweet);
sscanf(sweet, "%d", &n);
gets(sweet);
memset(sweetC, 0, sizeof sweetC);
memset(sourC, 0, sizeof sourC);
for(i=0; i<n; i++){
for(j=i; j<n; j++) {
if(sweet[j]=='1'){
if(i==j)
sweetC[i][j]=1;
else{
sweetC[i][j] = sweetC[i][j-1]+1;
sourC[i][j] = sourC[i][j-1];
}
}else{
if(i==j)
sourC[i][j]=1;
else{
sourC[i][j] = sourC[i][j-1]+1;
sweetC[i][j] = sweetC[i][j-1];
}
}
}
}
memset(dp, -1, sizeof dp);
printf("%d\n", recur(0, n-1));
}
return 0;
}
void main()
{
clrscr();
fin=fopen("file\\input.txt","r");
fout=fopen("file\\output.txt","w");
int repeat;
fscanf(fin,"%d",&repeat);
for (int s=0; s<repeat; s++)
{
fscanf(fin,"%d",&count);
arraycol=new int[count];
arrayrow=new int[count];
for(int i=0; i<count; i++)
{
arraycol[i]=0;
arrayrow[i]=0;
}
rebro * p=new rebro[count*count];
for(i=0; i<count; i++)
for(int j=0; j<count; j++)
{
fscanf(fin,"%d",&p[i*count+j].lenght);
if (i==j)
p[i*count+j].exist=1;
else
p[i*count+j].exist=0;
}
recur(p,count,0);
delete [] arraycol;
delete [] arrayrow;
delete [] p;
fprintf(fout,"%d\n",record);
record=-1;
}
fclose(fin);
fclose(fout);
}
void pocket_area(const CArea& area, const PocketParams& params, CPath& path)
{
g_params = params;
g_path = &path;
if(g_params.m_rapid_down_to_height > g_params.m_clearance_height)
g_params.m_rapid_down_to_height = g_params.m_clearance_height;
CArea::m_round_corners_factor = params.m_round_corner_factor;
std::list<const CArea*> arealist;
CArea* a_firstoffset = new CArea(area);
double first_offset = params.m_tool_diameter * 0.5 + params.m_material_allowance;
a_firstoffset->Offset(first_offset);
recur(arealist, a_firstoffset);
int layer_count = int((params.m_start_depth - params.m_final_depth) / params.m_step_down);
if(layer_count * params.m_step_down + 0.00001 < params.m_start_depth - params.m_final_depth)
layer_count++;
for(int i = 1; i< layer_count+1; i++)
{
double depth = params.m_final_depth;
if(i != layer_count)
depth = params.m_start_depth - i * params.m_step_down;
for(std::list<const CArea*>::iterator It = arealist.begin(); It != arealist.end(); It++)
{
const CArea* a = *It;
cut_area(*a, depth);
}
}
}
void main()
{
int ch;
char choice;
clrscr();
while(1)
{
clrscr();
printf("\n 1 enter the data by recursive form");
printf("\n 2 display");
printf("\n 3 represent");
printf("\n 4 exit");
printf("\n enter the choice ");
scanf("%d",&ch);
switch(ch)
{
case 1:
do
{
temp=malloc(sizeof(struct node)) ;
temp->left=NULL;
temp->right=NULL;
printf("\n enter the data");
scanf("%s",&temp->data);
if(root==NULL)
{
a[i]=(char*)malloc(strlen(temp->data));
;a[i]=temp->data;
strcpy(a[i],temp->data);
i++;
root=temp;
}
else
{
a[i]=(char*)malloc(strlen(temp->data));
strcpy(a[i],temp->data);
i++;
recur(root,temp);
}
printf("\n Do you want to enter more elements ");
scanf(" %c",&choice);
}while(choice=='y');
break;
case 2:
clrscr();
do
{
printf("\n 1 preorder");
printf("\n 2 inorder ");
printf("\n 3 postorder");
printf("\n exit");
printf("\n enter the choice");
scanf("%d",&c);
if(root==NULL)
printf("\n the tree is empty ");
else
tree(root,c) ;
getch(); }while(c!=4);
break;
case 3:
display();
case 4 :
exit(1);
break;
default:
printf("\n wrong choice entered");
break;
}
}
}
double jv(double n, double x)
{
double k, q, t, y, an;
int i, sign, nint;
nint = 0; /* Flag for integer n */
sign = 1; /* Flag for sign inversion */
an = fabs(n);
y = floor(an);
if (y == an) {
nint = 1;
i = an - 16384.0 * floor(an / 16384.0);
if (n < 0.0) {
if (i & 1)
sign = -sign;
n = an;
}
if (x < 0.0) {
if (i & 1)
sign = -sign;
x = -x;
}
if (n == 0.0)
return (j0(x));
if (n == 1.0)
return (sign * j1(x));
}
if ((x < 0.0) && (y != an)) {
mtherr("Jv", DOMAIN);
y = NPY_NAN;
goto done;
}
if (x == 0 && n < 0 && !nint) {
mtherr("Jv", OVERFLOW);
return NPY_INFINITY / gamma(n + 1);
}
y = fabs(x);
if (y * y < fabs(n + 1) * MACHEP) {
return pow(0.5 * x, n) / gamma(n + 1);
}
k = 3.6 * sqrt(y);
t = 3.6 * sqrt(an);
if ((y < t) && (an > 21.0))
return (sign * jvs(n, x));
if ((an < k) && (y > 21.0))
return (sign * hankel(n, x));
if (an < 500.0) {
/* Note: if x is too large, the continued fraction will fail; but then the
* Hankel expansion can be used. */
if (nint != 0) {
k = 0.0;
q = recur(&n, x, &k, 1);
if (k == 0.0) {
y = j0(x) / q;
goto done;
}
if (k == 1.0) {
y = j1(x) / q;
goto done;
}
}
if (an > 2.0 * y)
goto rlarger;
if ((n >= 0.0) && (n < 20.0)
&& (y > 6.0) && (y < 20.0)) {
/* Recur backwards from a larger value of n */
rlarger:
k = n;
y = y + an + 1.0;
if (y < 30.0)
y = 30.0;
y = n + floor(y - n);
q = recur(&y, x, &k, 0);
y = jvs(y, x) * q;
goto done;
}
if (k <= 30.0) {
k = 2.0;
}
else if (k < 90.0) {
k = (3 * k) / 4;
}
if (an > (k + 3.0)) {
if (n < 0.0)
k = -k;
q = n - floor(n);
k = floor(k) + q;
if (n > 0.0)
q = recur(&n, x, &k, 1);
else {
t = k;
k = n;
q = recur(&t, x, &k, 1);
k = t;
}
if (q == 0.0) {
underf:
y = 0.0;
goto done;
}
}
else {
k = n;
q = 1.0;
}
/* boundary between convergence of
* power series and Hankel expansion
*/
y = fabs(k);
if (y < 26.0)
t = (0.0083 * y + 0.09) * y + 12.9;
else
t = 0.9 * y;
if (x > t)
y = hankel(k, x);
else
y = jvs(k, x);
#if CEPHES_DEBUG
printf("y = %.16e, recur q = %.16e\n", y, q);
#endif
if (n > 0.0)
y /= q;
else
y *= q;
}
else {
/* For large n, use the uniform expansion or the transitional expansion.
* But if x is of the order of n**2, these may blow up, whereas the
* Hankel expansion will then work.
*/
if (n < 0.0) {
mtherr("Jv", TLOSS);
y = NPY_NAN;
goto done;
}
t = x / n;
t /= n;
if (t > 0.3)
y = hankel(n, x);
else
y = jnx(n, x);
}
done:
return (sign * y);
}
int main(){
int i,j, minC, curMin, minI, a, b, c;
while(scanf("%d %d", &m, &n)>0){
for(i=0; i<m; i++){
for(j=0; j<n; j++){
scanf("%d", &w[i][j]);
}
}
memset(vis, 0, sizeof dp);
minC=INF, minI=0;
for(i=0; i<m; i++){
curMin = recur(i, 0);
if(curMin<minC){
minC=curMin;
minI=i;
}
}
printf("%d", minI+1);
for(i=1; i<n; i++){
if(minI>0)
a=dp[minI-1][i];
else
a=dp[m-1][i];
b=dp[minI][i];
if(minI<m-1)
c=dp[minI+1][i];
else
c=dp[0][i];
if(minI==m-1){
if(a<=b){
if(a<c){
if(minI>0)
minI--;
else
minI=m-1;
}else{
minI=0;
}
}else{
if(c<=b){
minI=0;
}
}
}else if(minI>0){
if(a<=b){
if(a<=c){
minI--;
}else{
if(minI<m-1)
minI++;
else
minI=0;
}
}else{
if(c<b){
if(minI<m-1)
minI++;
else
minI=0;
}
}
}else if(minI==0){
if(a<b){
if(a<c){
minI=m-1;
}else{
minI++;
}
}else{
if(c<b){
if(minI<m-1)
minI++;
else
minI=0;
}
}
}
printf(" %d", (minI+1));
}
printf("\n%d\n", minC);
}
return 0;
}
void OEvent::fromMap( const QMap<int, QString>& map )
{
// We just want to set the UID if it is really stored.
if ( !map[OEvent::FUid].isEmpty() )
setUid( map[OEvent::FUid].toInt() );
setCategories( idsFromString( map[OEvent::FCategories] ) );
setDescription( map[OEvent::FDescription] );
setLocation( map[OEvent::FLocation] );
if ( map[OEvent::FType] == "AllDay" )
setAllDay( true );
else
setAllDay( false );
int alarmTime = -1;
if( !map[OEvent::FAlarm].isEmpty() )
alarmTime = map[OEvent::FAlarm].toInt();
int sound = ( ( map[OEvent::FSound] == "loud" ) ? OPimAlarm::Loud : OPimAlarm::Silent );
if ( ( alarmTime != -1 ) ){
QDateTime dt = startDateTime().addSecs( -1*alarmTime*60 );
OPimAlarm al( sound , dt );
notifiers().add( al );
}
if ( !map[OEvent::FTimeZone].isEmpty() && ( map[OEvent::FTimeZone] != "None" ) ){
setTimeZone( map[OEvent::FTimeZone] );
}
time_t start = (time_t) map[OEvent::FStart].toLong();
time_t end = (time_t) map[OEvent::FEnd].toLong();
/* AllDay is always in UTC */
if ( isAllDay() ) {
OTimeZone utc = OTimeZone::utc();
setStartDateTime( utc.fromUTCDateTime( start ) );
setEndDateTime ( utc.fromUTCDateTime( end ) );
setTimeZone( "UTC"); // make sure it is really utc
}else {
/* to current date time */
// qWarning(" Start is %d", start );
OTimeZone zone( timeZone().isEmpty() ? OTimeZone::current() : timeZone() );
QDateTime date = zone.toDateTime( start );
qWarning(" Start is %s", date.toString().latin1() );
setStartDateTime( zone.toDateTime( date, OTimeZone::current() ) );
date = zone.toDateTime( end );
setEndDateTime ( zone.toDateTime( date, OTimeZone::current() ) );
}
if ( !map[OEvent::FRecParent].isEmpty() )
setParent( map[OEvent::FRecParent].toInt() );
if ( !map[OEvent::FRecChildren].isEmpty() ){
QStringList list = QStringList::split(' ', map[OEvent::FRecChildren] );
for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
addChild( (*it).toInt() );
}
}
// Fill recurrence stuff and put it directly into the ORecur-Object using fromMap..
if( !map[OEvent::FRType].isEmpty() ){
QMap<int, QString> recFields;
recFields.insert( ORecur::RType, map[OEvent::FRType] );
recFields.insert( ORecur::RWeekdays, map[OEvent::FRWeekdays] );
recFields.insert( ORecur::RPosition, map[OEvent::FRPosition] );
recFields.insert( ORecur::RFreq, map[OEvent::FRFreq] );
recFields.insert( ORecur::RHasEndDate, map[OEvent::FRHasEndDate] );
recFields.insert( ORecur::EndDate, map[OEvent::FREndDate] );
recFields.insert( ORecur::Created, map[OEvent::FRCreated] );
recFields.insert( ORecur::Exceptions, map[OEvent::FRExceptions] );
ORecur recur( recFields );
setRecurrence( recur );
}
}
