I don't know the problem

use std::io;
use std::io::BufReader;
use std::io::BufRead;
fn minimal_product_digit(n: i64) -> i64{
    if n == 0 {return 10};
    if n < 10 { return n};

    let f : Vec<i64> = vec![2,3,5,7];
    let mut aux = n;
    let mut ret : Vec<i64> = Vec::new();
    for i in f{

        if  aux % i== 0 {

            loop{
                aux/=i;
                 ret.push(i);
                if aux % i != 0 {
                    break;
                }
            }
        }
    };

    if ret.is_empty() || aux > 1 {
        return -1;
    }

    match ret.iter().fold(0,|acc,elem| if *elem == 3{acc + 1} else {acc}) {

        1 => {

            let index = ret .iter().position(|&x| x == 3).unwrap();

            if index > 0{

                ret.remove(index);

                let k = ret.get_mut(index - 1).unwrap();

                *k = 6;

                ret.sort();

            }
        }

        _ => ()

    }
    let mut v : Vec<i64> = Vec::new();
    for i in ret{

        match i {

            2 | 3=>

                match v.last_mut(){

                    None => v.push(i),
                    Some(last) if i ==3 && *last == 2 => v.push(i),
                    Some(last) => {
                        let valor = *last;
                        if (valor * i) < 10{
                            *last = valor*i
                        }
                        else{
                            v.push(i);
                        }
                    }
                }
            _ => v.push(i)
        }
    }

        v.sort();
        v.iter().fold(0, |acc, elem| acc * 10 + elem)

}

fn main() {

    let mut line = String::new();
    let mut stdin = BufReader::new(io::stdin());

  stdin.read_line(&mut line).unwrap();

    let lim = line.trim().parse::<i64>().unwrap();

    println!("{:?}",minimal_product_digit(lim));

}

When n > 5 I guess, you can place one or more circles to free place within polygon?
I assume that answer for 5 and 6 is same

Edited by author 06.01.2021 17:11

One doesn't have to execute their actions followed by the other.
For instance:
Sandro can execute 7 consecutive actions and after that Zagamius could execute 20.
So basically, their turns don't need to be consecutive.
Misinterpretation will lead to WA#4 or WA#5.

Edited by author 05.01.2021 02:08

It is not said in the condition that the points have different coordinates. Can points have the same coordinates?

in some cases, there are more than 1 current user

Count numbers X and Y of quiet days for vacations given by intervals [1;r] and [1;l-1].

The answer to the problem would be ANS=X-Y.
How to count X and Y?

In the first step,  we eliminate every 2th.

That is,  CNT_0=r and and CNT_1=r//2

In the second step,  CNT_2=CNT_1//3.

And so on.

Until CNT > 0.

Last non-zero  CNT is the answer.

The 7th test case is:
2 5 1

And my program outputs 348.
I've tried to brute-force, and I got the same result. Did I misunderstand the problem?
What should be the output for this test case?

Input:
1 40 1
Output:
1099511627776

we can use the netflow algorithm(+ operator) to solve this problem.
#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 5
using namespace std;
const int INF=1<<30;
int n,m,flow[MAXN][MAXN],pre[MAXN],cur[MAXN],gap[MAXN],d[MAXN],g[MAXN],l[MAXN][MAXN];
int Maxflow_Isap(int s,int t,int n) {
    memset(d,-1,sizeof(d));
    memset(pre,-1,sizeof(pre));
    memset(gap,0,sizeof(gap));
    gap[s]=n;
    int u=pre[s]=s,v,maxflow=0;
    while (d[s]<n) {
      v=n+1;
      for (int i=cur[u];i<=g[u];i++)
        if (flow[u][l[u][i]] && d[u]==d[l[u][i]]+1) {
          v=l[u][i];cur[u]=i;break;
        }
      if (v<=n) {
        pre[v]=u;u=v;
        if (v==t) {
          int dflow=INF;u=s;
          for (int i=v;i!=s;i=pre[i]) dflow=min(dflow,flow[pre[i]][i]);
          maxflow+=dflow;
          for (int i=v;i!=s;i=pre[i]) {
            flow[pre[i]][i]-=dflow;
            flow[i][pre[i]]+=dflow;
          }
        }
      }
      else{
        int mindist=n;
        for (int i=1;i<=g[u];i++)
          if (flow[u][l[u][i]]) mindist=min(mindist,d[l[u][i]]);
        if (!--gap[d[u]]) return maxflow;
        gap[d[u]=mindist+1]++;cur[u]=1;
        u=pre[u];
      }
    }
    return maxflow;
}
void setsize(int x,int y,int c) {
    flow[x][y]=c;
    l[x][++g[x]]=y;
    l[y][++g[y]]=x;
}
int main() {
    scanf("%d%d",&n,&m);
    setsize(1,2,n);
    setsize(2,4,n);
    setsize(1,3,m);
    setsize(3,4,m);
    printf("%d\n",Maxflow_Isap(1,4,4));
    return 0;
}

Since the requirements became stronger, and time was reduced from 2 sec down to 1 sec, now it is not possible to resolve the task using bruteforce method, python is very slow for such hard requirements.

Even I do empty loops the taken time is already about 1.3 sec.

from time import time
time_before = time()

len_lst = 20

for i in range(1, ((2 ** len_lst) // 2) - 1):

    for j in range(len_lst):

        pass

print(time() - time_before)

>>> 1.3192360401153564

I think for Python the time should be rolled back to 2 sec.
Of cause if I use bruteforce on "C" it takes about 0.2 sec, but Python is not "C".

This problem is easier than rating should be if you know the trick.

Invariant: graph G is decomposable if and only if all the connected components of G has even number of edges.

A tree is very easy to be decomposed. Creating a tree equivalent to each connected component will lead to the answer.

Hope this help, Mick :)

I don`t understant brute-force , who can give your code to me ?

mail: k13795263@yahoo.cn



Edited by author 23.08.2008 05:40

i have got WA on test #5. Help me please. Thanks

If you got TLE on test>28, try this test
50000
0 0
0 0
... 50000 points (0,0)
0 0

I tried the following:

For every recognized language find the minimum and the maximum possible lines.
Then find the maximum and minimum possible lines for all.
For minimum to maximum test if it divides N.
This solves the first four tests.

Is this the right way?

So, if you can't understand what author of the problem meant, you're not alone :o)

He meant the following: chukcha goes from A to B and he covers each K kilometers in H hours. But the speed whithin this interval is not constant: he can cover K minus eps kilometers within first second of H hours and remaining eps kilometers in the remaining time (and visa versa).

It leads to the problem itself: what speed distribution along the interval leads to the minimum time to reach destination and what distribution leads to maximum time.

как понимать _минимальное_ и _максимальное_ время ???

Edited by author 01.11.2009 13:12

why taking the biggiest fraction of remain assure that the church gets the minimized?