solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <string>
#include <vector>
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<stack>
#include<queue>
#include<cmath>
#include<algorithm>
#include<functional>
#include<list>
#include<deque>
#include<bitset>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<cstring>
#include<sstream>
#include<complex>
#include<iomanip>
#include<numeric>
#include<cassert>
#include<random>
#define X first
#define Y second
#define pb push_back
#define rep(X,Y) for (int (X) = 0;(X) < (int)(Y);++(X))
#define reps(X,S,Y) for (int (X) = (int)(S);(X) < (int)(Y);++(X))
#define rrep(X,Y) for (int (X) = (int)(Y)-1;(X) >=0;--(X))
#define rreps(X,S,Y) for (int (X) = (int)(Y)-1;(X) >= (int)(S);--(X))
#define repe(X,Y) for ((X) = 0;(X) < (Y);++(X))
#define peat(X,Y) for (;(X) < (Y);++(X))
#define all(X) (X).begin(),(X).end()
#define rall(X) (X).rbegin(),(X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define Endl endl
#define NL <<"\n"
#define cauto const auto
using namespace std;
using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
template<class T> using vv=vector<vector<T>>;
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
//#undef NUIP
#ifdef NUIP
#include "benri.h"
#else
#define out(args...)
#endif
void ouT(ll x,int d=3){auto re=to_string(x);if((int)re.size()>d) re=x>0?"oo":"-oo";cout<<string(d-re.size(),' ')<<re<<",";}
#ifdef __cpp_init_captures
template<typename T>vector<T> table(int n, T v){ return vector<T>(n, v);}
template <class... Args> auto table(int n, Args... args){auto val = table(args...); return vector<decltype(val)>(n, move(val));}
#endif
template<class A,class B> pair<A,B> operator+(const pair<A,B> &p,const pair<A,B> &q){ return {p.X+q.X,p.Y+q.Y};}
template<class A,class B,class C,class D> pair<A,B>& operator+=(pair<A,B> &p,const pair<C,D> &q){ p.X+=q.X; p.Y+=q.Y; return p;}
template<class A,class B> pair<A,B> operator-(const pair<A,B> &p,const pair<A,B> &q){ return {p.X-q.X,p.Y-q.Y};}
template<class A,class B,class C,class D> pair<A,B>& operator-=(pair<A,B> &p,const pair<C,D> &q){ p.X-=q.X; p.Y-=q.Y; return p;}
template<class A,class B> istream& operator>>(istream &is, pair<A,B> &p){ is>>p.X>>p.Y; return is;}
template<class T=ll> T read(){ T re; cin>>re; return move(re);}
template<class T=ll> T read(const T &dec){ T re; cin>>re; return re-dec;}
template<class T=ll> vector<T> readV(const int sz){ vector<T> re(sz); for(auto &x:re) x=read<T>(); return move(re);}
template<class T=ll> vector<T> readV(const int sz, const T &dec){ vector<T> re(sz); for(auto &x:re) x=read<T>(dec); return move(re);}
vv<int> readG(const int &n,const int &m){ vv<int> g(n); rep(_,m){ cauto a=read<int>(1),b=read<int>(1); g[a].pb(b); g[b].pb(a);} return move(g);}
vv<int> readG(const int &n){ return readG(n,n-1);}
#define TT cauto TTT=read();rep(_,TTT)
const ll MOD=1e9+7; //998244353;
ll modpow_(ll r,ll n,ll m=MOD){
ll re=1,d=r%m;
if(n<0)(n%=m-1)+=m-1;
for(;n;n/=2){
if(n&1)(re*=d)%=m;
(d*=d)%=m;
}
return re;
}
template <int mod=MOD> struct ModInt{
int v;
ModInt(int v=0):v(v){}
ModInt operator+(const ModInt &n)const{return v+n.v<mod ? v+n.v : v+n.v-mod;}
ModInt operator-(const ModInt &n)const{return v-n.v<0 ? v-n.v+mod : v-n.v;}
ModInt operator*(const ModInt &n)const{return ll(v)*n.v%mod;}
ModInt operator/(const ModInt &n)const{return ll(v)*modpow_(n.v%mod,-1,mod)%mod;}
ModInt operator+(const ll &n)const{return v+n<mod ? v+n : v+n-mod;}
ModInt operator-(const ll &n)const{return v-n<0 ? v-n+mod : v-n;}
ModInt operator*(const ll &n)const{return ll(v)*(n%mod)%mod;}
ModInt operator/(const ll &n)const{return ll(v)*modpow_(n%mod,-1,mod)%mod;}
ModInt& operator+=(const ModInt &n){v+=n.v; if(v>=mod) v-=mod; return *this;}
ModInt& operator-=(const ModInt &n){v-=n.v; if(v<0) v+=mod; return *this;}
ModInt& operator*=(const ModInt &n){v=ll(v)*n.v%mod; return *this;}
ModInt& operator/=(const ModInt &n){v=ll(v)*modpow_(n.v,-1,mod)%mod; return *this;}
ModInt& operator+=(const ll &n){v+=n; if(v>=mod) v-=mod; return *this;}
ModInt& operator-=(const ll &n){v-=n; if(v<0) v+=mod; return *this;}
ModInt& operator*=(const ll &n){v=ll(v)*n%mod; return *this;}
ModInt& operator/=(const ll &n){v=ll(v)*modpow_(n,-1,mod)%mod; return *this;}
bool operator==(const ModInt &n)const{return v==n.v;};
bool operator!=(const ModInt &n)const{return v!=n.v;};
ModInt& operator++(){ return operator+=(1); }
ModInt& operator--(){ return operator-=(1); }
ModInt operator++(int i){ ModInt tmp(*this); operator++(); return tmp; }
ModInt operator--(int i){ ModInt tmp(*this); operator--(); return tmp; }
};
#ifdef NUIP
class MINT_FRAC____{
public:
unordered_map<int,pii> dict;
MINT_FRAC____(int n){
rep(p,n+1)reps(q,1,n+1)if(__gcd(p,q)==1){
dict[1ll*p*modpow_(q,-1)%MOD]=pii(p,q);
dict[MOD-1ll*p*modpow_(q,-1)%MOD]=pii(-p,q);
}
}
} Il1Il1Il1(1000);
template<int mod> ostream& operator<<(ostream &os,const ModInt<mod> &n){if(Il1Il1Il1.dict.count(n.v)) os<<n.v<<"("<<Il1Il1Il1.dict[n.v].X<<"/"<<Il1Il1Il1.dict[n.v].Y<<")";else os<<n.v;return os;};
#else
template<int mod> ostream& operator<<(ostream &os,const ModInt<mod> &n){return os<<n.v;};
#endif
template<int mod> ModInt<mod> operator+(const ll &n,const ModInt<mod> &m){return m.v+n<mod ? m.v+n : m.v+n-mod;}
template<int mod> ModInt<mod> operator-(const ll &n,const ModInt<mod> &m){return n-m.v<0 ? n-m.v+mod : n-m.v;}
template<int mod> ModInt<mod> operator*(const ll &n,const ModInt<mod> &m){return ll(m.v)*(n%mod)%mod;}
template<int mod> ModInt<mod> operator/(const ll &n,const ModInt<mod> &m){return ModInt<mod>(n%mod)/m;}
typedef ModInt<MOD> mint;
template <int mod> ModInt<mod> modpow(ModInt<mod> r,ll n){ ModInt<mod> re(1); if(n<0)(n%=mod-1)+=mod-1; for(;n;n/=2){if(n&1) re*=r; r*=r;} return re;}
vector<mint> fact,finv,inv;
mint comb(ll n,ll r){ if(n<r||r<0)return 0; return fact[n]*finv[n-r]*finv[r];}
class Doralion{
void Modinvs(vector<mint> &re,int n){ re.resize(n+1); re[1]=1; for(int i=2;i<=n;++i)re[i]=re[MOD%i]*(MOD-MOD/i);}
void Facts(vector<mint> &re,int n){ re.resize(n+1); re[0]=1; rep(i,n)re[i+1]=re[i]*(i+1);}
void Factinvs(vector<mint> &re,const vector<mint> &inv,int n){ re.resize(n+1); re[0]=1; rep(i,n)re[i+1]=re[i]*inv[i+1];}
public:
Doralion(int n){ Modinvs(inv,n); Facts(fact,n); Factinvs(finv,inv,n);}
} doralion(1123456);
using pmm=pair<mint,mint>;
mint modpow(ll r,ll n){ return modpow_(r,n);}
struct UF{
vector<int> data;
UF(int size):data(size,-1){}
bool unite(int x,int y){
x=root(x); y=root(y);
if(x!=y){
if(-data[y]>-data[x]) swap(x,y);
data[x]+=data[y]; data[y]=x;
}
return x!=y;
}
bool findSet(int x,int y){return root(x)==root(y);}
int root(int x){return data[x]<0?x:data[x]=root(data[x]);}
int size(int x) {return -data[root(x)];}
bool operator()(int x,int y){ return findSet(x,y);}
int operator[](int x){ return root(x);}
bool unti(int x,int y){ return unite(x,y);}
};
int main(){
ios_base::sync_with_stdio(false); cin.tie(0);
cout<<fixed<<setprecision(0);
cauto n=read();
cauto m=read();
vector<int> re;
UF uf(m+m);
rep(i,n){
cauto t=read();
out(i,t,1);
if(t==1){
cauto v=read(1);
out(v,1);
if(uf.unite(v,v+m)) re.eb(i);
}else{
cauto v=read(1);
cauto w=read(1);
out(i,t,v,w,1);
if(uf.unite(v,w)&uf.unite(v+m,w+m)) re.eb(i);
}
out(i,1);
}
out(re,1);
cout<<modpow(2,(int)re.size())<<" "<<re.size() NL;
for(cauto &v:re) cout<<v+1<<" ";
cout NL;
return 0;
}
| 12 |
CPP
|
#include <bits/stdc++.h>
#define endl '\n'
#define all(a) (a).begin(), (a).end()
#define len(a) (int) (a).size()
#define forn(i, n) for (int (i) = 0; (i) < (n); ++(i))
#define int long long
using namespace std;
void solve();
mt19937 rnd(2007);
signed main(){
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
swap(rng, rnd);
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
struct dsu{
vector<int> p;
dsu(int n){
p.resize(n);
forn (i, n) p[i] = i;
}
int get(int v){
if (p[v] == v)
return v;
return p[v] = get(p[v]);
}
bool unite(int v, int u){
v = get(v), u = get(u);
p[v] = u;
return v != u;
}
};
const int mod = (int) 1e9 + 7;
void solve() {
int m; cin >> m;
int n; cin >> n;
dsu ds(n + 1);
vector<int> ans;
forn (qwe, m){
int k; cin >> k;
if (k == 1){
int v; cin >> v;
if (ds.get(v) != ds.get(0)) {
ds.unite(v, 0);
ans.push_back(qwe + 1);
}
}
else {
int v, u; cin >> v >> u;
if (ds.unite(v, u)){
ans.push_back(qwe + 1);
}
}
}
int res = 1;
forn (qwe, len(ans)){
res *= 2;
res %= mod;
}
cout << res << ' ' << len(ans) << endl;
for (auto i : ans){
cout << i << ' ';
}
cout << endl;
}
| 12 |
CPP
|
/*
构造一个正交化的线性基
实现完全正交 is impossible;
退而求之局部正交,即crucial musk不能出现在其他向量中
竟然要用并查集我日你先人(
*/
#include<bits/stdc++.h>
#define ll long long
using namespace std;
#define pb push_back
const int ha = 1e9+7;
inline int add(int x,int y){ x+=y; return x>=ha?x-ha:x;}
inline void ADD(int &x,int y){ x+=y; if(x>=ha) x-=ha;}
inline int ksm(int x,int y){
int an=1;
for(;y;y>>=1,x=x*(ll)x%ha) if(y&1) an=an*(ll)x%ha;
return an;
}
class liner_base{
public:
int n,*e,*hd,*ne,*tl;
char *ex;
liner_base(int N) : n(N){
e = new int [N+5];
hd = new int [N+5];
ne = new int [N+5];
tl = new int [N+5];
ex = new char [N+5];
memset(hd,0,sizeof(int)*(N+3));
memset(ne,0,sizeof(int)*(N+3));
memset(tl,0,sizeof(int)*(N+3));
memset(ex,0,sizeof(char)*(N+3));
for(int i=0;i<=N;i++) e[i] = i;
}
~liner_base(){
/*
delete e;
delete hd;
delete ne;
delete tl;
delete ex;
*/
}
int gete(int x){ return e[x] == x ? x : (e[x] = gete(e[x]));}
inline void add_to_list(int Element,int List){
ne[Element] = hd[List];
e[Element] = List;
hd[List] = Element;
if(!tl[List]) tl[List] = Element;
}
void delete_list(int List){
for(int now = hd[List],NE;now;now = NE)
NE = ne[now] , e[now] = now , ne[now] = 0;
hd[List] = tl[List] = 0;
}
inline void alter_list(int List1,int List2){
if(!hd[List1]) return;
if(!hd[List2]) hd[List2] = hd[List1],tl[List2] = tl[List1];
else ne[tl[List2]] = hd[List1],tl[List2] = tl[List1];
hd[List1] = tl[List1] = 0;
}
inline void add(int x){ /*printf("add %d\n",x),*/ex[x] = 1,e[x] = x,delete_list(x);}
inline void add(int x,int y){ /*printf("add %d %d\n",x,y),*/ex[x] = 1,alter_list(x,y),add_to_list(x,y);}
inline bool insert(int x){
if(ex[x] && gete(x) == x) return 0;
if(ex[x]) add(gete(x));
else add(x);
return 1;
}
inline bool insert(int x,int y){
if(x == y) return 0;
if(ex[x] && (gete(x) == x)) return insert(y);
else if(ex[x]) return insert(min(gete(x),y),max(gete(x),y));
else if(ex[y] && gete(y) == y) return insert(x);
else if(ex[y]) return insert(x,gete(y));
else add(x,y);
return 1;
}
inline void consistent_check(){
int *color = new int [n+5];
memset(color,0,sizeof(int)*(n+3));
for(int i=1;i<=n;i++)
for(int j=hd[i];j;j=ne[j]) color[j] = i;
for(int i=1;i<=n;i++) if(ex[i] && !color[i]) color[i] = i;
for(int i=1;i<=n;i++) if(ex[i] && color[i] != gete(i))
printf("There is an unconsistent with node %d\ncolor is %d, but father is %d\n",i,color[i],gete(i));
}
inline void check(){
for(int i=1;i<=n;i++) if(ex[i]) printf("%d : %d\n",i,gete(i));
}
};
int main(){
// freopen("data.in","r",stdin);
// freopen("data.out","w",stdout);
int n,m; scanf("%d%d",&n,&m);
liner_base a(m);
queue<int> q;
for(int opt,X,Y,i=1;i<=n;i++){
scanf("%d",&opt);
if(opt==1){
scanf("%d",&X);
if(a.insert(X)) q.push(i);
}
else{
scanf("%d%d",&X,&Y);
if(a.insert(min(X,Y),max(X,Y))) q.push(i);
}
}
// a.consistent_check();
printf("%d %d\n",ksm(2,q.size()),(int)q.size());
while(!q.empty()) printf("%d ",q.front()),q.pop();
// a.check();
return 0;
}
| 12 |
CPP
|
#include "bits/stdc++.h"
using namespace std;
#define rep(i, a, b) for(int i=a; i<=b; i++)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int) x.size()
#define pb push_back
#define f first
#define s second
#define nl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int MOD = 1e9+7;
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;
int n, m;
vector<pii> e;
bool self[500001];
int par[500001];
int sz[500001];
bool del[500001];
bool vis[500001];
bool has[500001];
int find(int x){
if(x==par[x]) return x;
return par[x]=find(par[x]);
}
void join(int x, int y){
int a=find(x);
int b=find(y);
if(a!=b){
sz[a]+=sz[b];
par[b]=a;
has[a] |= has[b];
}
}
ll bpow(ll a, ll b){
if(b==0) return 1;
ll y=bpow(a, b/2);
y=(y*y)%MOD;
if(b&1) y=(y*a)%MOD;
return y;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n >> m;
rep(i, 1, m){
par[i]=i;
sz[i]=1;
}
rep(i, 1, n){
int x=-1; int y=-1;
int a;
cin >> a;
cin >> x;
if(a>1) cin >> y;
if(y==-1){
e.pb({x, x});
}
else e.pb({x, y});
}
ll ans=1;
rep(i, 0, sz(e)-1) {
pii p=e[i];
if(p.f!=p.s){
if(find(p.f)==find(p.s) || (has[find(p.f)] && has[find(p.s)])) del[i]=true;
}
else{
if(has[find(p.f)]) del[i]=true;
has[(find(p.f))]=true;
}
join(p.f, p.s);
}
rep(i, 1, m){
int p=find(i);
if(vis[p]) continue;
ans=(ans*bpow(2, sz[p]-1))%MOD;
if(has[p]) ans=(ans*2)%MOD;
vis[p]=true;
}
cout << ans << " ";
vi vec;
rep(i, 0, n-1){
if(!del[i]) vec.pb(i);
}
cout << sz(vec) << nl;
trav(k, vec) cout << k+1 << " ";
}
| 12 |
CPP
|
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 500000;
const long long modd = 1000000007;
int n, m;
int kk;
int aa[N + 5];
long long anss[N + 5], co = 0;
int ff[N + 5];
struct ab
{
int u;
int v;
} ee[N + 5];
long long qpow(long long a, long long b)
{
long long c = 1;
while (b)
{
if (b & 1)
{
c = c * a % modd;
}
a = a * a % modd;
b >>= 1;
}
return c;
}
int find(int x)
{
if (ff[x] != x)
{
return ff[x] = find(ff[x]);
}
return x;
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
{
scanf("%d", &kk);
ee[i].v = m + 1;
if (kk == 1)
{
scanf("%d", &ee[i].u);
}
else
{
scanf("%d%d", &ee[i].u, &ee[i].v);
}
}
for (int i = 1; i <= m + 1; ++i)
{
ff[i] = i;
}
for (int i = 1; i <= n; ++i)
{
int a = find(ee[i].u);
int b = find(ee[i].v);;
if (a != b)
{
ff[a] = b;
anss[++co] = i;;
}
}
printf("%lld %lld\n", qpow(2, co), co);
for (int i = 1; i <= co; ++i)
{
printf("%lld ", anss[i]);;
}
return 0;;
}
| 12 |
CPP
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pll pair<ll,ll>
ll inf = 4e18, mod = 1e9 + 7;
inline ll power(ll x, ll n, ll m = LLONG_MAX)
{
ll res = 1; x = (x % m + m) % m;
while (n)
{ if (n & 1) res = (res * x) % m;
x = (x * x) % m; n >>= 1;
}
return res;
}
int dsu[500005], siz[500005];
vector<int> res;
void init() {
for (int i = 0; i < 500005; i++) dsu[i] = i, siz[i] = 1;
}
int find_parent(int x) {
return dsu[x] == x ? x : find_parent(dsu[x]);
}
void merge(int x, int y, int z) {
x = find_parent(x);
y = find_parent(y);
if (x == y) return;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
dsu[y] = x;
res.push_back(z);
}
void solve() {
int n, m;
cin >> n >> m;
init();
set <pair<int, pair<int, int>>> s;
for (int i = 1; i <= n; i++) {
int k, x, y;
cin >> k;
if (k == 1) {
cin >> x;
s.insert({i, {0, x}});
}
else {
cin >> x >> y;
s.insert({i, {x, y}});
}
}
while (!s.empty()) {
auto it = s.begin();
pair<int, pair<int, int>> p = *it;
s.erase(it);
merge(p.second.first, p.second.second, p.first);
}
cout << power(2, res.size(), mod) << " " << res.size() << endl;
for (auto it : res)
cout << it << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) solve();
}
| 12 |
CPP
|
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
def __init__(self, file):
self.newlines = 0
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# --------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def S(): return input().strip()
def print_list(l): print(' '.join(map(str, l)))
# sys.setrecursionlimit(100000)
# import random
# from functools import reduce
# from functools import lru_cache
# from heapq import *
# from collections import deque as dq
# from math import gcd
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
def find(region, u):
path = []
while u != region[u]:
path.append(u)
u = region[u]
for v in path:
region[v] = u
return u
def union(region, u, v):
u, v = find(region, u), find(region, v)
region[u] = v
return u != v
n, m = RL()
M, ans, res, region = 10 ** 9 + 7, [], 1, list(range(m + 1))
for i in range(1, n + 1):
s = RLL()
t = s[2] if s[0] == 2 else 0
if union(region, s[1], t):
ans.append(i)
res = (res << 1) % M
print(res, len(ans))
print_list(ans)
| 12 |
PYTHON3
|
#include <bits/stdc++.h>
#define MOD 1000000007
#define all(x) x.begin(), x.end()
using namespace std;
typedef long long ll;
typedef vector<ll> dlist;
typedef vector<dlist> matrix;
struct DS{
vector<bool> uni;
vector<int> p, c;
DS(int n): p(n, 0), c(n, 1), uni(n, false){
for(int i = 0; i < n; ++i)
p[i] = i;
}
int SetOf(int x){
return (p[x] == x)? x : p[x] = SetOf(p[x]);
}
bool Merge(int x, int y){
x = SetOf(x);
y = SetOf(y);
if((x == y) || (uni[x] && uni[y]))
return false;
if(c[x] < c[y])
swap(x, y);
p[y] = x;
c[x] += c[y];
uni[x] = (uni[x] | uni[y]);
return true;
}
};
void solve(){
int n, m;
cin >> n >> m;
matrix data(n);
DS ds(m + 1);
vector<int> sel;
for(int i = 0; i < data.size(); ++i){
auto &x = data[i];
int v; cin >> v;
for(int j = 0; j < v; ++j){
int k; cin >> k;
x.push_back(k);
}
if(v == 1){
v = ds.SetOf(x[0]);
if(ds.uni[v]) continue;
ds.uni[v] = true;
}
else if(!ds.Merge(x[0], x[1]))
continue;
sel.push_back(i);
}
int cant = 0;
for(int i = 1; i <= m; ++i){
int v = ds.SetOf(i);
cant += (ds.c[v] - !ds.uni[v]) * (v == i);
}
ll ans = 1;
for(int i = 1; i <= cant; ++i)
ans = (ans * 2) % MOD;
cout << ans << " " << cant << "\n";
for(auto &x:sel)
cout << x + 1 << " \n"[&x == &sel.back()];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while(t--) solve();
return 0;
}//RUL0
| 12 |
CPP
|
#include <bits/stdc++.h>
#define LL long long
#define rep(i, s, t) for (register int i = (s), i##end = (t); i <= i##end; ++i)
#define dwn(i, s, t) for (register int i = (s), i##end = (t); i >= i##end; --i)
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -f;
for (; isdigit(ch); ch = getchar()) x = 10 * x + ch - '0';
return x * f;
}
int a[500010], fa[500010], vis[500010], mod = 1e9 + 7;
inline int find(int x) { return x==fa[x]?x:fa[x]=find(fa[x]); }
int main() {
int n = read(), m = read(), T = 0;
rep(i, 1, m) fa[i] = i;
rep(i, 1, n) {
int opt = read();
if(opt == 2) {
int u = read(), v = read();
u = find(u), v = find(v);
if((vis[u] && vis[v]) || u == v) continue;
fa[u] = v; vis[v] |= vis[u];
a[i] = 1; ++T;
} else {
int u = read(); u = find(u);
if(!vis[u]) a[i] = 1, T++, vis[u] = 1;
}
}
int cur = T, pns = 1, bs = 2;
rep(i, 1, T) pns = 2LL * pns % mod;
cout << pns << " " << T << endl;
rep(i, 1, n) if(a[i]) cout << i << " ";
}
| 12 |
CPP
|
import sys
input = sys.stdin.buffer.readline
class UnionFind:
def __init__(self, n):
self.parent = [-1] * n
self.n = n
self.cnt = n
def root(self, x):
if self.parent[x] < 0:
return x
else:
self.parent[x] = self.root(self.parent[x])
return self.parent[x]
def merge(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.parent[x] > self.parent[y]:
x, y = y, x
self.parent[x] += self.parent[y]
self.parent[y] = x
self.cnt -= 1
return True
def is_same(self, x, y):
return self.root(x) == self.root(y)
def size(self, x):
return -self.parent[self.root(x)]
def count(self):
return self.cnt
def groups(self):
res = [[] for _ in range(self.n)]
for i in range(self.n):
res[self.root(i)].append(i)
return [group for group in res if group]
n, m = map(int, input().split())
info = [list(map(int, input().split())) for i in range(n)]
MOD = 10 ** 9 + 7
uf = UnionFind(m)
start = []
res = []
for i, (k, *vs) in enumerate(info):
if len(vs) == 2:
u, v = vs
u -= 1
v -= 1
if not uf.is_same(u, v):
uf.merge(u, v)
res.append(i + 1)
else:
u = vs[0] - 1
if start:
if not uf.is_same(start[-1], u):
uf.merge(start[-1], u)
res.append(i + 1)
start.append(u)
else:
res.append(i + 1)
start.append(u)
print(pow(2, len(res), MOD), len(res))
print(*res)
| 12 |
PYTHON3
|
#include <stdio.h>
#include <vector>
using namespace std;
const int mod = 1e9 + 7;
int p[500001];
int find(int a) {
if (p[a] != a) p[a] = find(p[a]);
return p[a];
}
bool dsu(int a, int b) {
a = find(a); b = find(b);
if (a == b) return 0;
p[b] = a;
return 1;
}
int main() {
int i, n, m;
long long T = 1;
vector<int> S;
for (scanf("%d%d", &n,&m), i = 1; i <= m; ++i) p[i] = i;
for (i = 1; i <= n; ++i) {
int k, x1, x2;
scanf("%d%d",&k,&x1);
if (k > 1) scanf("%d",&x2);
else x2 = 0;
if (dsu(x1, x2)) {
T = (T + T) % mod;
S.push_back(i);
}
}
printf("%I64d %d\n",T,S.size());
for (auto x : S) printf("%d ",x);
return 0;
}
| 12 |
CPP
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
int MOD=1e9+7;
int id[500005], sz[500005];
int find(int x){
while(x!=id[x]){
id[x]=id[id[x]];
x=id[x];
}
return x;
}
void unite(int i, int j){
int x=find(i), y=find(j);
if(sz[x]<sz[y]) swap(x, y);
sz[x]+=sz[y];
id[y]=x;
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin>>n>>m;
for(int i=0;i<=m;i++){
id[i]=i;
sz[i]=1;
}
int ans=1;
vector<int>v;
for(int i=0;i<n;i++){
int k, x, y;
cin>>k>>x;
if(k==1) y=0;
else cin>>y;
if(find(x)!=find(y)){
unite(x, y);
ans=(ans*2)%MOD;
v.push_back(i+1);
}
}
cout<<ans<<" "<<v.size()<<"\n";
for(int i:v) cout<<i<<" ";
cout<<endl;
}
| 12 |
CPP
|
#include <bits/stdc++.h>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define int long long
#define ll long long
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define ff first
#define ss second
#define ld long double
#define pii pair<int, int>
#define prev prev228
#define left left228
#define right right228
#define dist dist228
#define tm tm228
using namespace std;
mt19937 rnd(time(nullptr));
const long long INF = 1e18, P = 1e9 + 7, N = 5e5 + 10;
const long double EPS = 1e-9;
int pr[N], rk[N], used[N];
vector<int> ans, to_used[N];
vector<pair<int, int> > ed;
map<pair<int, int>, int> mp;
int get_root(int x) {
return (x == pr[x] ? x : pr[x] = get_root(pr[x]));
}
void mrg(int y1, int y2) {
if (rk[y1] > rk[y2]) {
swap(y1, y2);
}
pr[y1] = y2;
if (rk[y1] == rk[y2]) {
rk[y2]++;
}
}
bool add(int v, int u) {
v = get_root(v);
u = get_root(u);
if (v == u) {
return false;
}
mrg(v, u);
return true;
}
void do_used(int x) {
used[x] = 1;
vector<int> st = {x};
while (st.size() > 0) {
int v = st.back();
st.pop_back();
for (int u : to_used[v]) {
if (!used[u]) {
used[u] = 1;
st.push_back(u);
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//cout << setprecision(15) << fixed;
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (k == 1) {
int x;
cin >> x;
x--;
if (!used[x]) {
ans.push_back(i + 1);
do_used(x);
}
} else {
int v, u;
cin >> v >> u;
v--;
u--;
mp[{v, u}] = i;
if (!used[v] || !used[u]) {
ed.push_back({v, u});
if (!used[v] && !used[u]) {
to_used[v].push_back(u);
to_used[u].push_back(v);
} else if (!used[v]) {
do_used(v);
} else if (!used[u]) {
do_used(u);
}
}
}
}
for (int i = 0; i < m; i++) {
pr[i] = i;
rk[i] = 1;
}
for (pair<int, int> p : ed) {
int v = p.ff, u = p.ss;
if (add(v, u)) {
ans.push_back(mp[{v, u}] + 1);
}
}
sort(all(ans));
int pw = 1;
for (int i = 0; i < ans.size(); i++) {
pw *= 2;
pw %= P;
}
cout << pw << ' ' << ans.size() << "\n";
for (int elem : ans) {
cout << elem << ' ';
}
cout << "\n";
return 0;
}
| 12 |
CPP
|
def findIndexGE(prefixSumsMax,startSum,query):
n=len(prefixSumsMax)
b=n
i=-1
while b>0:
while i+b<n and startSum+prefixSumsMax[i+b]<query:
i+=b
b//=2
i+=1
return i
def main():
t=int(input())
allans=[]
for _ in range(t):
n,m=readIntArr()
arr=readIntArr() #numbers of disk
queries=readIntArr()
prefixSums=arr.copy()
for i in range(1,n):
prefixSums[i]+=prefixSums[i-1]
maxP=max(prefixSums)
prefixSumsMax=prefixSums.copy()
for i in range(1,n):
prefixSumsMax[i]=max(prefixSumsMax[i-1],prefixSums[i])
ans=[]
for q in queries:
if prefixSums[n-1]<=0:
if q>maxP: #drive will run indefinitely
ans.append(-1)
else:
ans.append(findIndexGE(prefixSumsMax,0,q))
else:
#find number of cycles
nCycles=-1
b=10**9
while b>0:
while prefixSums[n-1]*(nCycles+b)+maxP<q:
nCycles+=b
b//=2
nCycles+=1
startSum=prefixSums[n-1]*nCycles
lastCycleIdx=findIndexGE(prefixSumsMax,startSum,q)
ans.append(nCycles*n+lastCycleIdx)
allans.append(ans)
multiLineArrayOfArraysPrint(allans)
return
#import sys
#input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
import sys
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
inf=float('inf')
MOD=10**9+7
main()
| 13 |
PYTHON3
|
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
typedef int _loop_int;
#define REP(i,n) for(_loop_int i=0;i<(_loop_int)(n);++i)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a);i<(_loop_int)(b);++i)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1;i>=(_loop_int)(a);--i)
#define DEB(x) cout << #x << " " << x << endl;
#define DEB_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define CHMIN(a,b) a=min((a),(b))
#define CHMAX(a,b) a=max((a),(b))
typedef long long int LL;
typedef pair<int, int> PI;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
typedef vector<LL> VL;
void solve() {
int n, m;
cin >> n >> m;
int a[n];
REP(i, n)
cin >> a[i];
// cout << "question " << endl;
// REP(i, n)
// cout << a[i] << " ";
// cout << endl;
LL peak = LONG_MIN;
LL sum = 0;
map<LL, int> mp;
REP (i, n) {
sum += a[i];
if (mp.count(sum) == 0 && peak < sum)
mp[sum] = i+1;
CHMAX(peak, sum);
}
// for (auto x: mp)
// cout << x.first << ": " << x.second << ", ";
// cout << endl;
LL offset = sum;
unordered_map<int, LL> res;
REP(q, m) {
int x;
cin >> x;
if (res.count(x)) {
cout << res[x] << " ";
continue;
}
// cout << "x " << x << " : ";
if (peak < x && offset <= 0) {
// cout << -1 << " inf" <<endl;
cout << -1 << " ";
continue;
}
// DEB(offset);
// if (peak >= x) {
// auto it = mp.lower_bound(x);
// // DEB(it->second);
// sec += it->second;
// // cout << sec << endl;
// cout << sec << " ";
// continue;
// }
LL k = peak >= x ? 0: (x-peak + offset-1) / offset;
// cout << "x " << x << " k " << k << endl;
LL sec = peak >= x? -1: n*k - 1;
// LL acc = 0;
LL koff = k*offset;
// LL now;
// REP(i, n) {
// acc += a[i];
// now = koff + acc;
// sec++;
// if (now > x) {
// break;
// }
// if (now == x)
// break;
// }
LL search = x - koff;
// DEB(search);
auto it = mp.lower_bound(search);
// DEB(it->second);
sec += it->second;
cout << sec << " ";
res[x] = sec;
}
cout << endl;
}
int main() {
IOS
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
/*
question
2 0
x 1 : -1
x 2 : 0
question
2 -1
x 2 : 0
x 1 : -2
1
3 3
1 2 4
3 1 2
3
3 3
1 2 4
3 1 2
2 2
2 0
1 2
2 2
2 -1
2 1
*/
| 13 |
CPP
|
//int max = 2 147 483 647 (2^31-1)
//ll max = 9 223 372 036 854 775 807 (2^63-1)
#include<bits/stdc++.h>
using namespace std;
#define forn(i,n) for(int i=0;i<n;i++)
#define mp make_pair
#define f first
#define s second
#define pb push_back
#define MOD 1000000007
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int,int> pi;
//Fast input and output
void fast_io(){
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);}
//Printing pairs and vectors
template<typename A, typename B> ostream& operator<< (ostream &cout, pair<A,B> const &p) {return cout << "(" << p.f << ", " << p.s << ")";}
template<typename A> ostream& operator<< (ostream &cout, vector<A> const&v){
cout << "["; forn(i,(int)v.size()){ if (i) cout << ", "; cout << v[i];} return cout << "]";}
ll divi(ll a, ll b){
if(a>=0) return a/b;
return (a+1)/b-1;
}
//main code
int main(){
fast_io();
//cout << divi(-1,2) << endl;
int test; cin >> test;
forn(tc,test){
int n,m; cin >> n >> m;
vector<ll> a(n);
forn(i,n) cin >> a[i];
vector<ll> pref=a;
for(int i=1;i<n;i++) pref[i]+=pref[i-1];
vector<ll>pmax=pref;
for(int i=1;i<n;i++) pmax[i]=max(pmax[i],pmax[i-1]);
//cout << pref << " " << pmax << endl;
forn(i,m){
ll x, ans=0; cin >> x;
if(pref[n-1]>0){
ans=max(divi((x-pmax[n-1]-1),pref[n-1])+1,(ll)0)*n;
x-=max(divi((x-pmax[n-1]-1),pref[n-1])+1,(ll)0)*pref[n-1];
}
//cout << x << " " << ans << "\n";
int l=-1,r=n-1;
while(l+1<r){
int m=(l+r)/2;
if(pmax[m]<x) l=m;
else r=m;
}
//cout << r << " ";
if(pmax[r]>=x) cout << ans+r << " ";
else cout << "-1 ";
}
cout << "\n";
}
}
| 13 |
CPP
|
#!/usr/bin/env python
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def main():
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
import sys
input = sys.stdin.readline
import math
import copy
import bisect
import collections
t = int(input())
for f in range(t):
n,m = map(int,input().split())
a = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = []
a_cum = [a[0]]
for i in range(n-1):
a_cum.append(a[i+1]+a_cum[-1])
a_cum_max = [a_cum[0]]
for i in range(n-1):
a_cum_max.append(max(a_cum_max[-1],a_cum[i+1]))
loop = a_cum[-1]
for i in range(m):
check = x[i]
if loop <= 0 and a_cum_max[-1] < check:
ans.append(-1)
else:
rep = 0
if loop > 0 and check > a_cum_max[-1]:
rep = (check-a_cum_max[-1]-1)//loop +1
else:
rep = 0
temp = rep*n
check -= rep*loop
temp += bisect.bisect_left(a_cum_max, check)
ans.append(temp)
print(*ans)
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
struct tr { ll r, s; int i; };
bool g(tr &a, tr &b) {
if(a.r == b.r && a.s == b.s) return a.i < b.i;
else if(a.r == b.r) return a.s > b.s;
else return a.r < b.r;
}
int main() {
ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
int t; cin>>t; while(t--) {
int n,m; cin>>n>>m;
vector<ll> a(n);
vector<pair<ll, pair<ll, int>>> p(n);
map<ll, int> mp;
for (int i = 0; i < n; ++i) {
cin>>a[i];
p[i].first = a[i] + (i > 0 ? p[i-1].first : 0);
if(i == 0 || p[i].first > p[i-1].second.first) {
p[i].second.first = p[i].first; p[i].second.second = i;
} else {
p[i].second.first = p[i-1].second.first; p[i].second.second = p[i-1].second.second;
}
mp[p[i].first] = i+1;
}
ll s = p[n-1].first;
for (int i = 0; i < m; ++i) {
ll x; cin>>x;
int l = -1, r = p[n-1].second.second+1; ll mx = p[n-1].second.first;
ll ans = (s <= 0 ? 0 : max(0LL, x-mx)/s + (max(0LL, x-mx) % s != 0));
while(l + 1 < r) {
int mid = (l + r) / 2;
if(ans * s + p[mid].second.first >= x) r = mid;
else l = mid;
}
if(r == p[n-1].second.second+1) cout << "-1 ";
else cout << ans*n + p[r].second.second << " ";
}
cout << "\n";
}
}
| 13 |
CPP
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
const int INF = 0x3f3f3f3f;
int t;
int n,m;
ll a[maxn];
ll res[maxn];
ll x[maxn];
int main()
{
cin >> t;
while(t--)
{
cin >> n >> m;
ll sum = 0;
ll ma = 0;
for(int i = 1;i <= n; ++i)
{
cin >> a[i];
sum += a[i];
ma = max(ma,sum);
res[i] = ma;
}
for(int i = 1;i <= m; ++i)
{
ll x;
cin >> x;
if(x > ma && sum <= 0)
cout << -1 << " ";
else if(x <= ma)
{
int ans = lower_bound(res + 1, res + 1 + n,x) - res - 1;
cout << ans << " ";
}
else
{
ll ans = -1;
ll k = max((ll)0,(x - ma + sum - 1) / sum);
ans += n * k;
x -= k * sum;
ans += lower_bound(res + 1, res + 1 + n,x) - res;
cout << ans << " ";
}
}
cout << endl;
}
return 0;
}
| 13 |
CPP
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define loop(a,b) for(ll i=a;i<b;i++)
#define pii pair<ll,ll>
#define F first
#define S second
#define mp make_pair
#define pb push_back
ll t,n,m,x,y,bal,MX;
vector<ll>a,pre,mx;
ll tell(ll x){
ll st=1,en=n,md,ans=0;
while(st<=en){
md=(st+en)/2;
if(mx[md]>=x) ans=md,en=md-1;
else st=md+1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
cin>>t;
while(t--){
cin>>n>>m;
a=pre=mx=vector<ll>(n+2);
for(ll i=1;i<=n;++i){
cin>>a[i];
pre[i]=pre[i-1]+a[i];
mx[i]=max(mx[i-1],pre[i]);
}
bal=pre[n];
MX=mx[n];
for(ll i=1;i<=m;++i){
cin>>x;
if(x-MX<=0) cout<<tell(x)-1<<' ';
else if(bal<=0) cout<<-1<<' ';
else{
y=ceil(((x-MX)*1.0)/bal);
cout<<y*n+tell(x-y*bal)-1<<' ';
}
}
cout<<'\n';
}
return 0;
}
| 13 |
CPP
|
#include<bits/stdc++.h>
using namespace std;
#define endl ("\n")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ll long long
#define llu long long unsigned
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define inpotp freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#define fr(i,n) for(int i=0;i<n;i++)
#define fr1(i,n) for(int i=1;i<=n;i++)
#define rfr(i,n) for(int i=n-1;i>=0;i--)
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define prdb(x) cout << fixed << setprecision(10) << x
#define sc(a) scanf("%d",&a)
#define pf(a) printf("%d",a)
#define cs(a) cout<<a<<' '
#define cn(a) cout<<a<<'\n'
#define ub(a,v) upper_bound(a.begin(), a.end(), v)
#define lb(a,v) lower_bound(a.begin(), a.end(), v)
int main()
{
fast
int t=1;
cin>>t;
while(t--){
ll n,m,a;
cin>>n>>m;
ll arr[n+1];
fr1(i,n)cin>>arr[i];
arr[0]=0;
fr1(i,n)arr[i]+=arr[i-1];
ll mx[n+1];
mx[1]=arr[1];
for(int i=2;i<=n;i++)mx[i]=max(mx[i-1],arr[i]);
while(m--){
cin>>a;
if(a<=arr[1]){cout<<"0 "; continue;}
if(a>mx[n] && arr[n]<=0){cout<<"-1 "; continue;}
ll ans=-1;
if(a>mx[n] && arr[n]>0){
ans+=((a-mx[n])/arr[n])*n;
a=a-( ((a-mx[n])/arr[n])*arr[n] );
}
// cout<<ans<<" "<<a<<endl;
int l=0,r=n,mid;
if(a>0){
l=0; r=n;
while(r-l>1){
mid=(l+r)/2;
if(mx[mid]>=a)r=mid;
else l=mid;
}
ans+=r;
a=a-arr[r];
}
// cout<<ans<<" "<<a<<endl;
if(a>0){
l=0; r=n;
while(r-l>1){
mid=(l+r)/2;
if(mx[mid]>=a)r=mid;
else l=mid;
}
ans+=r;
a=a-arr[r];
}
cout<<ans<<" ";
}
cout<<endl;
}
return 0;
}
| 13 |
CPP
|
from bisect import*
I=lambda:map(int,input().split())
for _ in range(*I(),):
n,m=I();p=[0];M=[0]
for v in I():p+=p[-1]+v,;M+=max(M[-1],p[-1]),
s=p[-1];a=[]
for x in map(int,input().split()):
r=0
if s>0:t=max((x-M[-1]+s-1)//s,0);r=t*n;x-=t*s
a+=[str(r+bisect_left(M,x)-1),'-1'][x>M[-1]],
print(*a)
| 13 |
PYTHON3
|
from collections import defaultdict
from bisect import bisect_right
import math
t=int(input())
for i in range(t):
n,u=map(int,input().split())
b=list(map(int,input().split()))
a=list(map(int,input().split()))
ans=[]
s=sum(b)
pre=[0]
for j in range(n):
pre.append(pre[-1]+b[j])
st = [0]
d = defaultdict(lambda:0)
d[0]=0
j=1
while(j<=n):
if pre[j]>st[-1]:
st.append(pre[j])
d[pre[j]]=j
j+=1
m=max(pre)
res=[]
for j in range(u):
if pre[-1]<=0:
if a[j]>m:
res.append(-1)
else:
ind = d[st[bisect_right(st, a[j] - 1)]]
res.append(ind-1)
else:
if a[j]<=m:
k=0
req=a[j]
else:
k=math.floor((a[j]-m)/pre[-1])
req=a[j]-k*pre[-1]
if req>m:
k+=1
req = a[j] - k * pre[-1]
ind=d[st[bisect_right(st,req-1)]]
res.append(max(0,k*n+ind-1))
print(*res)
| 13 |
PYTHON3
|
import sys
from bisect import bisect_left
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def solve():
n, m = map(int, input().split())
A = list(map(int, input().split()))
X = list(map(int, input().split()))
pref = []
ind = []
step = 0
for i, a in enumerate(A):
step += a
if not pref or step > pref[-1]:
pref.append(step)
ind.append(i)
res = [0] * m
for j, x in enumerate(X):
if pref[-1] < x and step <= 0:
res[j] = -1
else:
loop = 0
if pref[-1] < x:
loop = (x - pref[-1] + step - 1) // step
x -= loop * step
idx = bisect_left(pref, x)
res[j] = loop * n + ind[idx]
print(*res)
def resolve():
t = int(input())
for t in range(t):
solve()
if __name__ == '__main__':
resolve()
| 13 |
PYTHON3
|
t=int(input())
import math
import heapq
for _ in range(t):
n,m=map(int,input().split())
a=list(map(int,input().split()))
x=list(map(int,input().split()))
lis=[a[0]]
for i in range(1,n):
lis.append(lis[-1]+a[i])
one_round=lis[-1]
MAX=max(lis)
rests=[]
ans=[]
for q in x:
if MAX<q:
if one_round<=0:
pass
#ans.append(-1)
else:
round=math.ceil((q-MAX)/one_round)
rest=q-round*one_round
rests.append(rest)
#print(MAX,rest,one_round,round)
'''
for i in range(n):
if rest<=lis[i]:
ans.append(i+round*n)
break
'''
else:
rests.append(q)
'''
for i in range(n):
if q<=lis[i]:
ans.append(i)
break
'''
heapq.heapify(rests)
#print(rests)
dic=dict()
for i in range(n):
while True:
if len(rests)==0 or rests[0]>lis[i]:
break
temp=heapq.heappop(rests)
dic[temp]=i
for q in x:
if MAX<q:
if one_round<=0:
ans.append(-1)
else:
round=math.ceil((q-MAX)/one_round)
rest=q-round*one_round
ans.append(dic[rest]+round*n)
'''
for i in range(n):
if rest<=lis[i]:
ans.append(i+round*n)
break
'''
else:
ans.append(dic[q])
'''
for i in range(n):
if q<=lis[i]:
ans.append(i)
break
'''
print(' '.join(str(n) for n in ans))
| 13 |
PYTHON3
|
import io
import os
from collections import Counter, defaultdict, deque
from bisect import bisect_left
def solve(N, M, A, X):
pref = [0]
for x in A:
pref.append(pref[-1] + x)
for i in range(1, N + 1):
pref[i] = max(pref[i], pref[i - 1])
pref.pop(0)
cycleLen = N
cycleSum = sum(A)
excess = max(0, pref[-1] - cycleSum)
ans = []
for x in X:
t = bisect_left(pref, x)
if t < len(pref) and pref[t] >= x:
ans.append(t)
else:
if cycleSum <= 0:
ans.append(-1)
else:
fullCycles = (x - excess - 1) // cycleSum
x -= cycleSum * fullCycles
base = fullCycles * cycleLen
assert 0 <= x <= pref[-1]
t = bisect_left(pref, x)
ans.append(base + t)
return " ".join(map(str, ans))
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
X = [int(x) for x in input().split()]
ans = solve(N, M, A, X)
print(ans)
| 13 |
PYTHON3
|
import math
def answer(n,a,m):
s = 0
max_sum = a[0]
p_sums = [(a[0], 1)]
for i in range(n):
s+=a[i]
if s>max_sum:
max_sum = s
p_sums.append((s, i+1))
length = len(p_sums)
x = list(map(int, input().split()))
for i in range(m):
xi = x[i]
if s<=0 and max_sum<xi:
print(-1, end = " ")
continue
if xi<=max_sum:
rounds = 0
else:
rounds = math.ceil((xi-max_sum)/s)
xi -= rounds*s
l = 0
r = length-1
while(l<r):
mid = (l+r)//2
if p_sums[mid][0]<xi:
l = mid+1
else:
r = mid
print(rounds*n+p_sums[l][1]-1, end = " ")
print("")
t = int(input())
for i in range(t):
[n,m] = list(map(int , input().split()))
a = list(map(int, input().split()))
answer(n,a,m)
| 13 |
PYTHON3
|
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
# from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
try:
# sys.setrecursionlimit(int(pow(10,6)))
sys.stdin = open("input.txt", "r")
# sys.stdout = open("../output.txt", "w")
except:
pass
def pmat(A):
for ele in A:
print(*ele,end="\n")
from bisect import bisect_left
for i in range(int(input())):
n, m = map(int,input().split())
a = list(map(int,input().split()))
p = [0]*(n+1)
M = [0]*(n+1)
for i in range(n):
p[i+1] = p[i] + a[i]
M[i+1] = max(M[i], p[i+1])
s = p[-1]
ans = []
for x in map(int,input().split()):
r = 0
if s > 0:
t = max((x-M[-1]+s-1)//s,0)
r += t*n
x -= t*s
if x > M[-1]:
ans.append('-1')
else:
pos = bisect_left(M,x)
ans.append(str(r + pos - 1))
print(' '.join(ans))
endtime = time.time()
# print(f"Runtime of the program is {endtime - starttime}")
| 13 |
PYTHON3
|
#include<stdio.h>
#define N 200007
#define ll long long
inline int read(){
int x=0,flag=1; char c=getchar();
while(c<'0'||c>'9'){if(c=='-') flag=0;c=getchar();}
while(c>='0'&&c<='9'){x=(x<<1)+(x<<3)+c-48;c=getchar();}
return flag? x:-x;
}
int T,n,m,a[N],top,pos[N];
ll sta[N];
int main(){
T=read();
while(T--){
n=read(),m=read();
ll now=0; top=0;
for(int i=1;i<=n;i++){
a[i]=read(),now+=a[i];
if(sta[top]<now) sta[++top]=now,pos[top]=i;
}
if(now<=0){
for(int i=1;i<=m;i++){
int x=read();
if(x>sta[top]) printf("-1 ");
else{
int l=1,r=top,ret=top;
while(l<=r){
int mid=(l+r)>>1;
if(sta[mid]>=x) r=mid-1,ret=mid;
else l=mid+1;
}
printf("%d ",pos[ret]-1);
}
}
putchar('\n');
}else{
for(int i=1;i<=m;i++){
int x=read();
ll tmp=x>sta[top]? (x-sta[top]-1)/now+1:0;
ll ans=1ll*n*tmp;
x-=tmp*now;
int l=1,r=top,ret=top;
while(l<=r){
int mid=(l+r)>>1;
if(sta[mid]>=x) r=mid-1,ret=mid;
else l=mid+1;
}
printf("%lld ",ans+pos[ret]-1);
}
putchar('\n');
}
}
}
| 13 |
CPP
|
// Author :: <Hitesh_Saini>
#include<bits/stdc++.h>
#define __speed() ios_base::sync_with_stdio(false), cin.tie(nullptr);
#define dbg(x) cout << "(" << __LINE__ << ": "<< #x << " = " << x << ")\n"
#define Yes(x) print((x) ? "Yes" : "No")
#define tt int t; for (cin >> t; t--; )
#define f0(i, n) for (i = 0; i < (int)(n); i++)
#define f1(i, n) for (i = 1; i <=(int)(n); i++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)(x.size())
#define EB emplace_back
#define PB push_back
#define endl "\n"
#define S second
#define F first
using namespace std;
using mii = map<int, int>;
using pii = pair<int, int>;
using ll = int64_t;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
const int mod = 1e9+7, mxN = 5e6+5, INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
template <typename... T> void print(T... args) { ((cout << args << " "), ...), cout << endl; }
template <typename T1, typename T2> istream& operator>>(istream& in, pair<T1, T2>& p) { in >> p.F >> p.S; return in; }
template <typename T1, typename T2> ostream& operator<<(ostream& ot, pair<T1, T2>& p) { ot << p.F << ' ' << p.S; return ot; }
template <typename T1, typename T2> bool cmax(T1& a, T2 b) { if (b > a) { a = b; return true;} return false; }
template <typename T1, typename T2> bool cmin(T1& a, T2 b) { if (b < a) { a = b; return true;} return false; }
template <typename T> istream& operator>>(istream& in, vector<T>& v) { for (T& x:v) in >> x; return in; }
template <typename T> ostream& operator<<(ostream& ot, vector<T>& v) { for (T& x:v) ot << x << ' '; return ot; }
void solve() {
ll n, m, i, required, sum = 0;
cin >> n >> m;
vl A(n), pref_max(n);
f0(i, n) {
cin >> A[i];
sum += A[i];
if (i==0)
pref_max[i] = sum;
else
pref_max[i] = max(sum, pref_max[i-1]);
}
while (m--) {
cin >> required;
if (required > pref_max.back() && sum <= 0) {
cout << "-1 ";
continue;
}
ll cycles = 0, c = 0;
if (required > pref_max.back()) { // cycles exist
cycles = (required - pref_max.back() + sum - 1) / sum;
c = cycles * n;
required -= cycles * sum;
}
c += lower_bound(all(pref_max), required) - pref_max.begin();
cout << c << ' ';
}
cout << endl;
}
signed main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#endif
__speed() tt solve();
}
| 13 |
CPP
|
from bisect import *
import math
for _ in range(int(input())):
n,m=map(int,input().split())
arr=list(map(int,input().split()))
xs=list(map(int,input().split()))
pre=[]
for i in range(n):
try:
pre.append((pre[-1][0]+arr[i],i))
except:
pre.append((arr[i],i))
cy=pre[-1][0]
pp=[]
m=pre[0][0]
idx=0
for x,y in pre:
if x>m:
m=x
idx=y
pp.append((m,idx))
pp.sort(key=lambda x:x[0])
pr=[]
for i in pp:
pr.append(i[0])
m=pr[-1]
out=[]
for i in xs:
if i<=m:
idx=bisect_left(pr,i)
out.append(pp[idx][1])
else:
if cy>0:
r=math.ceil((i-m)/cy)
t=n*r+pp[bisect_left(pr,i-cy*r)][1]
out.append(t)
else:
out.append(-1)
print(*out)
| 13 |
PYTHON3
|
import math
from bisect import bisect_left, bisect_right
import sys
def get_ints(): return list(map(int, sys.stdin.readline().strip().split()))
T = int(input())
for _ in range(T):
N, M = get_ints()
A = get_ints()
X = get_ints()
# Q = []
# for i in range(M):
# Q.append((X[i], i))
# Q.sort()
last_val = 0
presum = []
index = []
sort_presum = []
max_val = float('-inf')
for i in range(N):
if not presum or presum[-1] < last_val + A[i]:
presum.append(last_val + A[i])
index.append(i)
# sort_presum.append((last_val + A[i], i))
# max_val = max(max_val, presum[-1])
last_val += A[i]
# sort_presum.sort()
vis = {}
q_idx = 0
p_idx = 0
for q_idx in range(M):
val = X[q_idx]
if presum[-1] < val and last_val <= 0:
vis[q_idx] = -1
continue
if presum[-1] < val:
t = math.ceil((val - presum[-1]) / last_val)
else:
t = 0
val -= t * last_val
i = bisect_left(presum, val)
vis[q_idx] = t * N + index[i]
# print(vis)
ans = [str(vis[i]) for i in range(M)]
print((" ").join(ans))
| 13 |
PYTHON3
|
#pragma GCC optimize("Ofast")
#pragma loop_opt(on)
#include<bits/stdc++.h>
#define Rushia_mywife ios::sync_with_stdio(0);cin.tie(0);
#define F first
#define S second
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define mp make_pair
#define mt make_tuple
#define FL cout.flush()
#define all(x) (x).begin(),(x).end()
#define mem(x,i) memset((x),(i),sizeof((x)))
using namespace std;
using ll = long long;
using pii = pair<int,int>;
using pll = pair<long long,long long>;
using ld = long double;
mt19937 mtrd(chrono::steady_clock::now().time_since_epoch().count());
const int mod = 1000000007;
const int mod2 = 998244353;
const ld PI = acos(-1);
#define Bint __int128
#define int long long
int qpow(int x,int powcnt,int tomod){
int res = 1;
for(;powcnt;powcnt>>=1,x=(x*x)%tomod)
if(1&powcnt)res = (res*x)%tomod;
return (res%tomod);
}
int inv(int x){ return qpow(x,mod-2,mod); }
// --------------------------------------**
int n,m;
void solve(){
cin >> n >> m;
int sum = 0;
vector<int>a(n);
for(int i=0;i<n;i++)
cin >> a[i];
vector<int>mx(n);
sum = mx[0] = a[0];
for(int i=1;i<n;i++)
sum += a[i],mx[i] = max(sum,mx[i-1]);
while(m--){
int x;
cin >> x;
if(mx[n-1]<x&&sum<=0){
cout << -1 << ' ';
continue;
}
int cir;
if(x<=mx[n-1])
cir = 0;
else
cir = (x-mx[n-1]+sum-1)/sum;
x -= cir*sum;
int ans = cir*n;
assert(x<=mx[n-1]);
int l = 0,r = n-1;
while(l<r){
int mid = (l+r)>>1;
if(mx[mid]>=x)
r = mid;
else
l = mid+1;
}
cout << ans+l << ' ';
}
cout << '\n';
}
signed main(){
Rushia_mywife
int t = 1;
cin >> t;
while(t--)
solve();
}
| 13 |
CPP
|
#include"bits/stdc++.h"
#define int long long
#define mod 1000000007
#define pf push_forward
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define f(i,in,n) for(i=in; i<n; ++i)
#define scant int t,t2055; cin>>t2055;for(t=1;t<=t2055;t++)
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
scant {
int n, m, i, j;
cin >> n >> m;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
int sum = 0; map<int, int>m1;
for (i = 0; i < n; i++) {
sum += a[i];
if (m1.empty()) {
m1[sum] = i;
}
auto x = m1.end(); x--;
if (x->first < sum) {
m1[sum] = i;
}
}
while (m--) {
int x; cin >> x;
auto lb = m1.lower_bound(x);
if (lb != m1.end()) {
cout << lb->second << " "; continue;
}
if (sum <= 0) {
cout << -1 << " "; continue;
}
int mx; auto temp = m1.end(); temp--;
mx = temp->first;
x -= mx;
int turns = x / sum;
int left = x % sum;
left += mx;
if (left > mx) {
turns++;
left -= sum;
}
turns *= n;
turns--;
// cout << m1.lower_bound(left)-> << endl;
if (left > 0) {
lb = m1.lower_bound(left);
turns += lb->second;
// cout << m1[1];
turns++;
}
cout << turns << " ";
}
cout << endl;
}
}
| 13 |
CPP
|
from math import ceil
for _ in range(int(input())):
n, m = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a)
mpfa = [0] * n
mpfi = 0
pf = mpfa[0] = a[0]
for i in range(1, n):
pf += a[i]
if pf > mpfa[i - 1]:
mpfi = i
mpfa[i] = pf
else:
mpfa[i] = mpfa[i - 1]
ans = []
xli = map(int, input().split())
for x in xli:
if x <= mpfa[-1]:
# binary search
low = 0
high = n - 1
while low < high:
mid = (low + high) // 2
if mpfa[mid] >= x:
high = mid
else:
low = mid + 1
ans.append(high)
continue
elif s <= 0:
ans.append(-1)
else:
iters = ceil((x - mpfa[-1]) / s)
# binary search
low = 0
high = n - 1
while low < high:
mid = (low + high) // 2
if mpfa[mid] >= (x - s * iters):
high = mid
else:
low = mid + 1
ans.append(iters * n + high)
print(*ans)
| 13 |
PYTHON3
|
from bisect import bisect_left
tc = int(input())
for _ in range(tc):
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
x = list(map(int, input().split()))
Val = sum(a)
process = []
ret = []
curr = 0
index = {}
for i in range(n):
curr += a[i]
if i == 0:
process.append(curr)
index[curr] = i
elif curr > process[-1]:
process.append(curr)
index[curr] = i
localBig = process[-1]
for num in x:
if localBig < num and Val <= 0:
ret.append('-1')
continue
spins = 0
if localBig < num:
spins = (num-localBig+Val-1)//Val
num -= spins * Val
pos = spins * n + index[process[bisect_left(process, num)]]
ret.append(str(pos))
print(' '.join(ret))
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
#define fu(i,a,b) for (long long i=a; i<=b; i++)
#define fd(i,a,b) for (long long i=a; i>=b; i--)
using namespace std;
typedef long long ll;
const ll N=2e5+10;
ll n,q,a[N],s[N],ma[N],query[N];
void Solve()
{
cin>>n>>q;
fu(i,1,n)
{
cin>>a[i];
}
fu(i,1,q)
{
cin>>query[i];
}
fu(i,1,n)
{
s[i]=s[i-1]+a[i];
}
ma[0]=0;
fu(i,1,n)
{
ma[i]=max(ma[i-1],s[i]);
}
// fu(i,1,n)
// {
// cout<<s[i]<<" ";
// }
// cout<<"\n";
// fu(i,1,n)
// {
// cout<<ma[i]<<" ";
// }
// cout<<"\n";
if (s[n]<=0)
{
fu(i,1,q)
{
ll x=query[i];
ll l=1,r=n,res=0;
while (l<=r)
{
ll mid=(l+r)/2;
if (ma[mid]>=x)
{
res=mid;
r=mid-1;
}
else
{
l=mid+1;
}
}
cout<<res-1<<" ";
}
cout<<"\n";
return;
}
fu(i,1,q)
{
ll x=query[i];
ll L=0,R=(x/s[n])+10,res=0;
// cout<<"Tra loi "<<x<<":\n";
while (L<=R)
{
ll MID=(L+R)/2;
// cout<<MID<<":\n";
ll val=MID*s[n];
ll l,r,o=-1;
if (MID==0) {l=1;} else {l=0;}
r=n;
while (l<=r)
{
ll mid=(l+r)/2;
// cout<<l<<" "<<r<<" "<<mid<<"\n";
if (ma[mid]>=x-val)
{
o=mid;
r=mid-1;
}
else
{
l=mid+1;
}
}
// cout<<"\n";
// cout<<o<<"\n";
if (o==-1)
{
L=MID+1;
}
else
{
res=MID*n+o;
R=MID-1;
}
}
cout<<res-1<<" ";
// cout<<"\n";
}
// cout<<"---------------\n";
cout<<"\n";
}
int main()
{
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
ll T;
cin>>T;
while (T--)
{
Solve();
}
}
| 13 |
CPP
|
#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define lln long long int
#define ld long double
#define all(x) (x).begin(),(x).end()
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
const int MOD = 1e9 + 7;
int main(){
IOS;
int a1;
cin >> a1;
for(int TT=0;TT<a1;TT++){
int n, m;
cin >> n >> m;
vector<int> A(n);
vector<pair<lln,int>> pref;
for(int i=0;i<n;i++) cin >> A[i];
pref.push_back({A[0], 0});
lln ma = A[0], sum = A[0];
for(int i=1;i<n;i++){
sum += A[i];
if(sum > pref.back().first) pref.push_back({sum, i});
ma = max(ma, pref.back().first);
}
for(int i=0;i<m;i++){
int q;
cin >> q;
if(q <= A[0]){
cout << 0 << " ";
continue;
}
if(q > ma && sum <= 0){
cout << -1 << " ";
continue;
}
lln cal = 0, ans = 0;
if(ma < q){
ans = ((q - ma) / sum );
if((q - ma) % sum) ans ++;
q = q - ans * sum;
ans = ans * n;
}
int l = 0, r = pref.size() - 1;
while(q > 0 && l <= r){
int m = (l + r) / 2;
if(pref[m].first >= q){
cal = m;
r = m - 1;
}
else l = m + 1;
}
cout << ans + pref[cal].second << " ";
}
cout << endl;
}
return 0;
}
| 13 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
#define m_p make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
typedef long long ll;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 200005;
int n, qq;
int a[N];
ll p[N];
void solv()
{
scanf("%d%d", &n, &qq);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i)
p[i] = p[i - 1] + a[i];
vector<pair<ll, int> > v;
for (int i = 1; i <= n; ++i)
v.push_back(m_p(p[i], i));
sort(all(v));
vector<int> s(sz(v) + 1);
s[sz(v)] = N;
for (int i = sz(v) - 1; i >= 0; --i)
s[i] = min(s[i + 1], v[i].se);
while (qq--)
{
int x;
scanf("%d", &x);
int i = lower_bound(all(v), m_p(x * 1LL, 0)) - v.begin();
if (s[i] == N)
{
if (p[n] <= 0)
{
printf("-1 ");
continue;
}
ll ans = (x / p[n]) * n + n;
int l = 1, r = (x / p[n]);
while (l <= r)
{
int u = (l + r) / 2;
ll yans = (u * 1LL * n);
ll xx = x;
xx -= u * 1LL * p[n];
int i = lower_bound(all(v), m_p(xx, 0)) - v.begin();
if (s[i] != N)
{
ans = u * 1LL * n + s[i];
r = u - 1;
}
else
l = u + 1;
}
printf("%lld ", ans - 1);
}
else
printf("%d ", s[i] - 1);
}
printf("\n");
}
int main()
{
#ifdef SOMETHING
freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#endif // SOMETHING
//ios_base::sync_with_stdio(false), cin.tie(0);
int tt = 1;
scanf("%d", &tt);
while (tt--)
solv();
return 0;
}
| 13 |
CPP
|
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------------------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=-10**6, func=lambda a, b: max(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=10**6, func=lambda a, b: min(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(200001)]
pp=[0]*200001
def SieveOfEratosthenes(n=200000):
# Create a boolean array "prime[0..n]" and initialize
# all entries it as true. A value in prime[i] will
# finally be false if i is Not a prime, else true.
p = 2
while (p * p <= n):
# If prime[p] is not changed, then it is a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
#---------------------------------running code------------------------------------------
for _ in range (int(input())):
n,m=map(int,input().split())
a=list(map(int,input().split()))
pre=[]
s=0
prev=0
for i in range (n):
s+=a[i]
if s>prev:
pre.append((s,i+1))
prev=s
#print(pre)
b=list(map(int,input().split()))
for k in b:
if k<=prev:
l,r=0,len(pre)-1
res=0
while l<=r:
mid=(l+r)//2
if pre[mid][0]>=k:
res=pre[mid][1]
r=mid-1
else:
l=mid+1
print(res-1)
continue
if s<=0:
print(-1)
continue
res=(k-prev)//s
num=0
if (k-prev)%s==0:
num=prev
else:
res+=1
num=k-res*s
r1=0
#print(res,num)
l,r=0,len(pre)-1
while l<=r:
mid=(l+r)//2
if pre[mid][0]>=num:
r1=pre[mid][1]
r=mid-1
else:
l=mid+1
#print(mid,r1)
print(res*n+r1-1)
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
int get(vector<int> &a, int n, int k)
{
int low = 0, high = n - 1, ans = -1 ;
while (low <= high)
{
int mid = (low + high) / 2;
if (a[mid] >= k)
{
ans = mid + 1;
high = mid - 1;
}
else
low = mid + 1;
}
return ans;
}
void solve()
{
int n, m, sum = 0;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin >> a[i];
sum += a[i];
a[i] = sum;
if (i)
a[i] = max(a[i], a[i - 1]);
}
for (int i = 0; i < m; ++i)
{
int k;
cin >> k;
int ans = get(a, n, k);
if (ans != -1)
cout << ans - 1 << ' ';
else
{
if (sum <= 0)
cout << -1 << ' ';
else
{
int low = 1, high = k / sum + (k % sum), ans = n * k;
while (low <= high)
{
int mid = (low + high) / 2;
int x = get(a, n, k - mid * sum);
if (x != -1)
{
ans = min(mid * n + x, ans);
high = mid - 1;
}
else
low = mid + 1;
}
cout << ans - 1 << ' ';
}
}
}
cout << '\n';
}
int32_t main(int32_t argc, char const *argv[])
{
int t;
cin >> t;
while (t --)
solve();
return 0;
}
| 13 |
CPP
|
import sys
zz=1
sys.setrecursionlimit(10**5)
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('all.txt','w')
di=[[-1,0],[1,0],[0,1],[0,-1]]
def fori(n):
return [fi() for i in range(n)]
def inc(d,c,x=1):
d[c]=d[c]+x if c in d else x
def ii():
return input().rstrip()
def li():
return [int(xx) for xx in input().split()]
def fli():
return [float(x) for x in input().split()]
def dadd(d,p,val):
if p in d:
d[p].append(val)
else:
d[p]=[val]
def gi():
return [xx for xx in input().split()]
def gtc(tc,ans):
print("Case #"+str(tc)+":",ans)
def cil(n,m):
return n//m+int(n%m>0)
def fi():
return int(input())
def pro(a):
return reduce(lambda a,b:a*b,a)
def swap(a,i,j):
a[i],a[j]=a[j],a[i]
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def gh():
sys.stdout.flush()
def isvalid(i,j,n,m):
return 0<=i<n and 0<=j<m
def bo(i):
return ord(i)-ord('a')
def graph(n,m):
for i in range(m):
x,y=mi()
a[x].append(y)
a[y].append(x)
t=fi()
uu=t
while t>0:
t-=1
n,q=mi()
a=li()
pre=[0]
m=[]
for i in a:
pre.append(pre[-1]+i)
pre.pop(0)
m=[pre[0]]
for i in range(1,n):
m.append(max(m[-1],pre[i]))
p=li()
for i in range(q):
c=pre[-1]
x=p[i]
if c<=0 and m[-1]<x:
print(-1,end=" ")
continue
l=cur=0
r=x
#print(x)
while l<=r:
mid=(l+r)//2
if mid*c<x-m[-1]:
l=mid+1
else:
cur=mid
r=mid-1
ans=cur*n
x-=cur*c
l=cur=0
r=n-1
while l<=r:
mid=(l+r)//2
if m[mid]<x:
l=mid+1
else:
cur=mid
r=mid-1
ans+=cur+1
print(ans-1,end=" ")
print()
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<ll> vl;
typedef pair<ll, ll> pll;
#define St first
#define Nd second
#define Pb push_back
#define print_pair(p) "{" << (p).St << ", " << (p).Nd << "} "
#define list_format(i, n) (i!=n? " ":"\n")
#define endl "\n"
#define sz(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define REP(i,a,b) for(int i = a; i <= b; i++)
#define REV(i,a,b) for(int i = a; i >= b; i--)
#define AritSum(a,d,n) ((n)*(2*(a)+((n)-1)*(d)))/2
#define Log(base, num) log2(num)/log2(base)
#define MOD 1000000007
#define INF 1e9
// ******************** Add-on *****************************
// ******************** Add-on *****************************
// ************* MAIN *******************
void precompute() {}
ll n, m, A[200000], mx[200000];
void solve() {
cin >> n >> m;
ll ma = 0, cur = 0;
REP(i,0,n-1) cin >> A[i], cur += A[i], ma = max(ma, cur), mx[i + 1] = max(mx[i], ma);
REP(i,0,m-1) {
ll x; cin >> x;
ll ans = 0;
if (x > ma && cur <= 0) {
cout << -1 << " ";
continue;
}
if (x > ma) {
ll temp = x - ma;
ll complete = (temp + cur - 1) / cur;
ans += complete * n;
x -= complete * cur;
}
int l = 1, r = n, b = n;
while (l <= r) {
int mid = (l + r)/2;
if (mx[mid] >= x) {
b = mid;
r = mid - 1;
} else l = mid + 1;
}
cout << ans + b - 1 << " ";
}
cout << endl;
}
/*
g++ -std=c++14 -Wall -Wextra -O2 Test.cpp -o Test
./Test < in.txt
*/
int main() {
precompute();
int _=1;
cin>>_;
REP(t,1,_) {
// cout << "Case #" << t << ": ";
solve();
// cout << ((solve())? "YES" : "NO") << endl;
}
return 0;
}
| 13 |
CPP
|
#include<bits/stdc++.h>
using namespace std;
template <class T> ostream &operator << (ostream &os, const vector<T> &p) { os << "["; for (auto&it : p) os << it << " "; return os << "]";}
template <class S, class T> ostream &operator << (ostream &os, const pair<S, T> &p) { return os << "(" << p.first << "," << p.second << ")";}
#ifndef ONLINE_JUDGE
#define deb(...) dbs(#__VA_ARGS__,__VA_ARGS__)
template <class T> void dbs(string str, T t) { cerr << str << ":" << t << "\n";}
template<class T, class...S> void dbs(string str, T t, S... s) { int idx = str.find(','); cerr << str.substr(0, idx) << ":" << t << ","; dbs(str.substr(idx + 1), s...);}
#else
#define deb(...){}
#endif
#define int long long
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i,n) for(int i = 0; i < n; i++)
#define sz(x) (int)x.size()
#define nl cout<< '\n'
#define pr(x) {cout << x << "\n"; return;}
#define all(x) x.begin(), x.end()
#define re(i,n) for(int i = 1; i <= n; i++)
#define prl(x) {cout << x << "\n";}
#define ini(x, y) memset(x, y, sizeof(x))
#define fr(i,a,b) for(int i = a; i <= b; i++)
#define fb(i,a,b) for(int i = a; i >= b; i--)
#define vi vector<int>
#define pii pair<int, int>
#define vii vector<pii>
template<class T> bool umin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool umax(T &a, T b) { return a < b ? (a = b, true) : false; }
void solve() {
int n, q; cin >> n >> q;
vi a(n);
int mx = -1e18, sum = 0;
vii v;
map<int, int> m;
rep(i, n) {
int x; cin >> x;
sum += x;
a[i] = x;
if (sum > mx) {
mx = sum;
m[sum] = i + 1;
}
}
deb(v);
while (q--) {
int x; cin >> x;
if (sum > 0) {
int r = (x / sum) * n;
int rem = x % sum;
if (rem > 0) {
auto pos = *m.lower_bound(rem);
r += pos.se;
}
int ans = r;
int l = 0, ri = 1e9;
while (l <= ri) {
int mid = (l + ri) / 2;
int have = mid * sum;
int rem = x - have;
int r = mid * n;
if (mx >= rem) {
if (rem > 0) {
auto pos = *m.lower_bound(rem);
r += pos.se;
}
umin(ans, r);
ri = mid - 1;
} else l = mid + 1;
}
cout << ans - 1 << ' ';
} else if (sum <= 0 && mx >= x) {
int rem = x;
auto pos = m.lower_bound(rem);
auto it = *pos;
deb(it);
int r = it.se;
cout << r - 1 << ' ';
} else cout << "-1 ";
}
nl;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int q = 1;
cin >> q;
while (q--) solve();
return 0;
}
| 13 |
CPP
|
import os
import sys
from bisect import bisect_left
from collections import Counter
from io import BytesIO, IOBase
from math import ceil
def f(n):
return int(n)%3
def main():
from collections import Counter
for _ in range(int(input())):
n, m = map(int, input().split())
a = [int(X) for X in input().split()]
pre = [a[0]]
tt = a[0]
y = sum(a)
for i in range(1, n):
tt += a[i]
pre.append(max(pre[-1], tt))
mn = []
qq=[int(X) for X in input().split()]
for j in qq:
if y <= 0:
op = bisect_left(pre, j)
mn.append(-1 if op == n else op )
else:
tmp = max(0, j - pre[-1])
j -= ceil(tmp / y) * y
op = bisect_left(pre, j)
mn.append(op + n * ceil(tmp / y))
print(*mn)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
| 13 |
PYTHON3
|
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
using namespace std;
#define ll long long
#define maxn 200005
ll t,n,m,a[maxn],k;
map<ll,ll> v;
ll bs(ll c){
ll l=0,r=k;
while(l<r){
ll m=(l+r)/2;
if(a[m]>=c) r=m;
else l=m+1;
}
if(r==k) return -1;
return v[a[l]];
}
int main(){
cin>>t;
while(t--){
//cout<<' '<<t<<endl;
cin>>n>>m;
ll res=0;
v.clear();k=0;
for(int i=1;i<=n;i++){
ll c;cin>>c;
res+=c;
if(res>=0&&!v[res]){
if(!k||(res>a[k-1])){
v[res]=i;
a[k++]=res;
}
}
}
for(int i=0;i<m;i++){
ll c,p,h=0;cin>>c;
if(res<=0) p=bs(c);
else{
if(c>a[k-1]){
h=(c-a[k-1])/res;
if((c-a[k-1])%res) h+=1;
c-=h*res;
}
p=bs(c);
if(p!=-1) p+=h*n;
}
if(p!=-1) p-=1;
cout<<p<<' ';
}
cout<<endl;
}
return 0;
}
| 13 |
CPP
|
from bisect import bisect_left
import math
ii = lambda : int(input())
li = lambda:list(map(int,input().split()))
t = int(input())
for _ in range(t):
n,m = li(); a = li();xl = li()
mx = []; curSum = 0;mxind = [];res = []
for i in range(n):
curSum+=a[i]
if mx==[] or mx[-1]<curSum:
mx.append(curSum); mxind.append(i)
for x in xl:
if (x>mx[-1] and curSum<=0):
res.append(-1)
else:
temp = 0
if (x>mx[-1]):
dif = x-mx[-1];temp = math.ceil(dif/curSum)
res.append(temp*n+mxind[bisect_left(mx,x-temp*curSum)])
print(*res)
| 13 |
PYTHON3
|
import bisect
t = int(input())
for i in range(t):
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
x = list(map(int, input().split()))
pre = 0
max_e = -float('inf')
min_e = float('inf')
s = []
for j in range(n):
pre += a[j]
if pre > max_e:
max_e = pre
s.append((pre, j))
res = []
for xi in x:
if pre <= 0:
index = bisect.bisect_left(s, (xi, 0))
if index == len(s):
res.append(-1)
else:
res.append(s[index][-1])
else:
cur = 0
loop = 0
if xi > s[-1][0]:
loop = ((xi - s[-1][0] - 1) // pre) + 1
cur += loop * n
xi -= loop * pre
index = bisect.bisect_left(s, (xi, 0))
# print(xi, index, s, s[index], s[index][-1] + cur)
res.append(s[index][-1] + cur)
print(*res)
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
#define F first
#define S second
#define all(x) x.begin(),x.end()
#define endl '\n'
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int MOD = 1000000007;
const int dx[] = { 0, 0, -1, 1, 1, -1, 1, -1};
const int dy[] = {-1, 1, 0, 0, 1, -1, -1, 1};
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL);
int t;
cin >> t;
while(t--){
int n, m;
cin >> n >> m;
vector<ll> v(n);
for(int i=0; i<n; i++){
cin >> v[i];
}
ll sum = 0, mx=-INFLL;
for(int i=0; i<n; i++){
sum += v[i];
mx = max(mx, sum);
v[i] = mx;
}
for(int i=0; i<m; i++){
ll x;
cin >> x;
if(x <= mx){
ll p = lower_bound(all(v), x) - v.begin();
cout << p << " ";
}else{
if(sum <= 0){
cout << -1 << " ";
}else{
ll y = (x-mx)/sum;
ll ans = y*n;
x -= y*sum;
while(x > mx){
ans += n;
x -= sum;
}
ll p = lower_bound(all(v), x) - v.begin();
cout << ans + p << " ";
}
}
}
cout << endl;
}
return 0;
}
| 13 |
CPP
|
#import sys
from bisect import bisect_left
#input = sys.stdin.readline
def solve():
n, m = map(int,input().split())
a = list(map(int,input().split()))
p = [0]*(n+1)
M = [0]*(n+1)
for i in range(n):
p[i+1] = p[i] + a[i]
M[i+1] = max(M[i], p[i+1])
s = p[-1]
ans = []
#print(p,M)
for x in map(int,input().split()):
r = 0
if s > 0:
t = max((x-M[-1]+s-1)//s,0)
r += t*n
x -= t*s
if x > M[-1]:
ans.append('-1')
else:
pos = bisect_left(M,x)
ans.append(str(r + pos - 1))
print(' '.join(ans))
for i in range(int(input())):
solve()
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int tc;cin>>tc;
while(tc--)
{
int n,m;cin>>n>>m;
vector<int> v(n);
for(int i=0;i<n;i++)cin>>v[i];
vector<long long> ps={v[0]}, ix={0};
long long sp=v[0];
for(int i=1;i<n;i++)
{
sp+=v[i];
if(sp>=ps.back()){ps.push_back(sp);ix.push_back(i);}
}
for(int i=0;i<m;i++)
{
int x;cin>>x;
if(ps.back()<x && sp<=0){cout<<"-1 ";continue;}
long long ts = 0LL;
if(ps.back()<x)ts=(x-ps.back()+sp-1)/sp;
int pos = ix[lower_bound(ps.begin(),ps.end(), x-(sp*1LL*ts))-ps.begin()];
cout<<pos+(ts*(n))<<" ";
}
cout<<endl;
}
}
| 13 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned uint;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ldbl;
typedef pair<int, int> pii;
typedef pair<uint, uint> puu;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pull;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<uint> vu;
typedef vector<ll> vll;
typedef vector<ull> vull;
typedef vector<pii> vpii;
typedef vector<puu> vpuu;
typedef vector<pll> vpll;
typedef vector<pull> vpull;
typedef vector<string> vstr;
typedef vector<double> vdbl;
typedef vector<ldbl> vldbl;
#define pb push_back
#define ppb pop_back
#define pfr push_front
#define ppfr pop_front
#define emp emplace
#define empb emplace_back
#define be begin
#define rbe rbegin
#define all(x) (x).be(), (x).end()
#define rall(x) (x).rbe(), (x).rend()
#define fir first
#define sec second
#define mkp make_pair
#define brif(cond) if (cond) break
#define ctif(cond) if (cond) continue
#define retif(cond) if (cond) return
void canhazfast() {ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);}
template<typename T> T gcd(T a, T b) {return b ? gcd(b, a%b) : a;}
template<typename T> T extgcd(T a, T b, T &x, T &y)
{
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a/b; a %= b; swap(a, b);
x0 -= q*x1; swap(x0, x1);
y0 -= q*y1; swap(y0, y1);
}
x = x0; y = y0; return a;
}
int ctz(uint x) {return __builtin_ctz(x);}
int ctzll(ull x) {return __builtin_ctzll(x);}
int clz(uint x) {return __builtin_clz(x);}
int clzll(ull x) {return __builtin_clzll(x);}
int popcnt(uint x) {return __builtin_popcount(x);}
int popcntll(ull x) {return __builtin_popcountll(x);}
int bsr(uint x) {return 31^clz(x);}
int bsrll(ull x) {return 63^clzll(x);}
#define N 200016
int a[N];
pair<ll, int> hi[N];
void solve()
{
int n, m, k = 0;
ll sum = 0, smx = 0;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
if (smx < sum) {
smx = sum;
hi[k++] = mkp(sum, i);
}
}
for (; m; --m) {
int x;
ll ans = 0;
cin >> x;
if (x > smx) {
if (sum <= 0) {
cout << "-1 ";
continue;
}
ll d = x-smx;
int q = (d-1)/sum+1;
ans = (ll)q*n;
x -= q*sum;
}
ans += lower_bound(hi, hi+k, mkp((ll)x, 0))->sec;
cout << ans << ' ';
}
cout << '\n';
}
int main()
{
canhazfast();
int t;
cin >> t;
for (; t; --t) solve();
return 0;
}
| 13 |
CPP
|
from bisect import *
from random import *
from itertools import *
import sys
read = sys.stdin.readline
write = lambda x, end="\n": sys.stdout.write(x + end)
def naive(a, q, t, m):
if t <= 0 and m < q:
return -1
x = 0
for i in count():
x += a[i % len(a)]
if x >= q:
return i
def g(a, q, t, m):
return bisect_left(d, q)
def f(a, q, t, m):
if t <= 0 and m < q:
return -1
elif q <= m:
return g(a, q, t, m)
z = 0 if t == 0 else max(0, (q - m) // t)
return z * len(a) + g(a, q - t * z, t, m)
# for _ in range(1000):
# n = m = 10
# a = [randint(-100, 100) for _ in range(10)]
# c = list(accumulate(a))
# d = list(accumulate(list(accumulate(a + a)), max))
# m = max(c)
# t = sum(a)
# for _ in range(100):
# q = randint(1, 10**4)
# x = f(a, q, t, m)
# y = naive(a, q, t, m)
# assert x == y, (x, y, a, q)
for _ in range(int(read())):
n, m = map(int, read().split())
a = list(map(int, read().split()))
c = list(accumulate(a))
d = list(accumulate(list(accumulate(a + a)), max))
# print(d)
m = max(c)
t = sum(a)
res = []
z = []
for q in map(int, read().split()):
z.append(f(a, q, t, m))
#res.append(naive(a, q, t, m))
print(*z)
# print(*res)
# print()
| 13 |
PYTHON3
|
#TESTING FAST IO AGAIN
import io,os,sys
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
in_length = int(input())
final_ouput = []
def find_minimum_stop(array, element, start, end):
mid = (start+end)//2
if start == end:
return 0
if element == array[mid]:
return mid
if element <= array[mid+1] and element> array[mid]:
return mid+1
elif element > array[mid+1]:
return find_minimum_stop(array, element, mid+1, end)
elif element < array[mid]:
return find_minimum_stop(array, element, start, mid)
for i in range(in_length):
index_saver = dict()
[n, m] = input().decode().split()
acc_sum = 0
sum_arr = input().decode().split()
questions = input().decode().split()
biggest_num = 0;
index_saver.update([(-1,-1)])
check_arr = [-1]
for j in range(int(n)):
acc_sum += int(sum_arr[j])
sum_arr[j] = acc_sum
if acc_sum > biggest_num:
index_saver.update([(sum_arr[j], j)])
biggest_num = acc_sum
check_arr.append(sum_arr[j])
diff = sum_arr[-1]
out_arr = []
if diff <= 0:
for q in questions:
if int(q) > biggest_num:
out_arr.append('-1')
else:
min_index = index_saver[check_arr[find_minimum_stop(check_arr, int(q), 0, len(check_arr)-1)]]
out_arr.append(str(min_index))
else:
cycle_arr = check_arr[find_minimum_stop(check_arr, biggest_num-diff, 0, len(check_arr)-1):]
cycle_arr.insert(0, -1)
for q in questions:
if int(q) <= biggest_num:
cycles = 0
else:
cycles = (int(q)-biggest_num)/diff
if cycles.is_integer():
cycles = (int(q)-biggest_num)//diff
else:
cycles = (int(q)-biggest_num)//diff + 1
if cycles == 0:
min_index = index_saver[check_arr[find_minimum_stop(check_arr, int(q), 0, len(check_arr)-1)]]
out_arr.append(str(min_index))
else:
min_index = index_saver[cycle_arr[find_minimum_stop(cycle_arr, int(q)-diff*cycles, 0, len(cycle_arr)-1)]]
out_arr.append(str(min_index + int(n)*(cycles)))
final_ouput.append(' '.join(out_arr))
for out in final_ouput:
sys.stdout.write(out + "\n")
| 13 |
PYTHON3
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[200010];
ll x[200010];
ll sa[200010];
ll sama[200010];
int psama[200010];
inline ll read(){
ll f=1,x=0;char ch;
do{ch=getchar();if(ch=='-')f=-1;}while(!isdigit(ch));
do{x=x*10+ch-'0';ch=getchar();}while(isdigit(ch));
return f*x;
}
int main(){
ll t;
cin>>t;
while(t--){
ll n,m;cin>>n>>m;
for(ll i=1;i<=n;i++)a[i]=read();
for(ll i=0;i<m;i++)x[i]=read();
for(ll i=1;i<=n;i++)sa[i]=sa[i-1]+a[i];
for(int i=1;i<=n;i++){
if(sama[i-1]<sa[i]){
sama[i]=sa[i];
psama[i]=i;
}else{
sama[i]=sama[i-1];
psama[i]=psama[i-1];
}
}
ll rd=sa[n];
for(ll i=0;i<m;i++){
if(rd<=0){
if(sama[n]<x[i])cout<<-1<<' ';
else {
int lop=lower_bound(sama+1,sama+1+n,x[i])-sama;
cout<<psama[lop]-1<<' ';
}
}else {
if(sama[n]<x[i]){
ll tmp=x[i]-sama[n];
ll tcp;
if(tmp%rd==0)tcp=tmp/rd;
else tcp=tmp/rd+1;
int lop=lower_bound(sama+1,sama+1+n,x[i]-tcp*rd)-sama;
cout<<n*tcp+psama[lop]-1<<' ';
}else{
int lop=lower_bound(sama+1,sama+1+n,x[i])-sama;
cout<<psama[lop]-1<<' ';
}
}
}
cout<<endl;
}
}
//author: caramel_pudding
| 13 |
CPP
|
for k in range(int(input())):
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
x=list(map(int,input().split()))
b=0
c=0
d=0
e=[]
y=[]
n1=0
for i in range(n):
if d==0:
if a[i]>0:
b+=a[i]
e.append([b,i])
n1+=1
else:
d=1
c=a[i]
else:
c+=a[i]
if c>0:
d=0
e.append([b+c,i])
b+=c
n1+=1
c=0
f=b+c
if e==[]:
y=[-1 for i in range(m)]
else:
g=e[-1][0]
for i in range(m):
if x[i]<=g:
l=n1/2
h=round(l)
while round(l)>0:
if e[h][0]<x[i]:
h=min(n1-1,h+round(l/2))
else:
h=max(0,h-round(l/2))
l/=2
h-=1
while h>0 and e[h][0]==e[h+1][0]:
h-=1
h=max(h,0)
while e[h][0]<x[i]:
h+=1
y.append(e[h][1])
elif f>0:
x1=(x[i]-g)//f
if (x[i]-g)%f!=0:
x1+=1
x[i]-=x1*f
l=n1/2
h=round(l)
while round(l)>0:
if e[h][0]<x[i]:
h=min(n1-1,h+round(l/2))
else:
h=max(0,h-round(l/2))
l/=2
h-=1
while h>0 and e[h][0]==e[h+1][0]:
h-=1
h=max(h,0)
while e[h][0]<x[i]:
h+=1
y.append(e[h][1]+n*x1)
else:
y.append(-1)
print(*y)
| 13 |
PYTHON3
|
from math import ceil
def find():
n, m = map(int, input().split())
a = list(map(int, input().split()))
x = list(map(int, input().split()))
sum_a = 0
pref = {}
pref_s = [0]
for j in range(n):
sum_a += a[j]
if sum_a not in pref:
pref[sum_a] = j
if a[j] > 0 and sum_a > pref_s[-1]:
pref_s.append(sum_a)
for j in x:
ans = 0
if j <= pref_s[-1]:
my_pref = j
else:
if sum_a <= 0:
print(-1, end=' ')
continue
else:
tmp = ceil((j - pref_s[-1]) / sum_a)
my_pref = max(0, j - tmp * sum_a)
ans += tmp * n
ind_min = 1
ind_max = len(pref_s) - 1
while ind_min != ind_max:
ind_new = (ind_min + ind_max) // 2
if pref_s[ind_new] < my_pref:
ind_min = ind_new + 1
else:
ind_max = ind_new
print(ans + pref[pref_s[ind_max]], end=' ')
print()
for i in range(int(input())):
find()
| 13 |
PYTHON3
|
#include<iostream>
#include<algorithm>
using namespace std;
const int N=2e6+5;
typedef long long ll;
long long n,m;
long long a[N],s[N],v[N],id[N];
int main(){
int t;
scanf("%d",&t);
while(t--){
scanf("%lld%lld",&n,&m);
for(int i=0;i<=n;i++)s[i]=v[i]=0;
ll tot=0;
for(int i=1;i<=n;i++){
scanf("%lld",&a[i]);
s[i]=s[i-1]+a[i];
if(!tot||s[i]>v[tot]) v[++tot]=s[i],id[tot]=i;
}
while(m--){
ll q;
scanf("%lld",&q);
if(q>v[tot]&&s[n]<=0)puts("-1 ");//公式：r*s[n]+max{s[i]}>=q 由于延长后的序列是单调的，所以当 s[n]<=0，截距max{s[i]}<q时公式无解
else{
int r=0;
if(v[tot]<q)//r*s[n]>=q-max{s[i]},max{s[i]}<q时r>=1
r=(q-v[tot]+s[n]-1)/s[n];// 向下取整
q-=r*s[n];
printf("%lld ",r*n+id[lower_bound(v+1,v+1+tot,q)-v]-1);//二分
}
}
puts("");
}
return 0;
}
| 13 |
CPP
|
/***************************/
/** Author : thantrongtri3 */
/***************************/
#include <bits/stdc++.h>
using namespace std;
namespace IO{
void setIn(string s) {freopen(s.c_str(), "r", stdin);}
void setOut(string s) {freopen(s.c_str(), "w", stdout);}
void setIO(string s = ""){
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
cin.exceptions(cin.failbit);
#endif // ONLINE_JUDGE
if (s.size()){
setIn(s+".inp");
setOut(s+".out");
} else{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif // ONLINE_JUDGE
}
}
}
using namespace IO;
namespace Function{
template <typename T1, typename T2> bool amax(T1 &a, T2 b){
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> bool amin(T1 &a, T2 b){
if (a > b){
a = b;
return 1;
}
return 0;
}
template <typename T> void compress(T &a){
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
}
template <typename T1, typename T2, typename T3> int position(T1 Begin, T2 End, T3 val, bool type = 0){
if (type == 0){
return lower_bound(Begin, End, val) - Begin;
}
return upper_bound(Begin, End, val) - Begin;
}
template <typename T> long long sqr(T x) {return 1LL * x * x;}
template <typename T1, typename T2> long long GCD(T1 a, T2 b) {return b == 0 ? a : GCD(b, a % b);}
template <typename T1, typename T2> long long LCM(T1 a, T2 b) {return 1LL * a / GCD(a, b) * b;}
}
using namespace Function;
namespace Output{
char End_Of_Stream = '\n';
void print(int x) {cout << x << End_Of_Stream;}
void print(unsigned int x) {cout << x << End_Of_Stream;}
void print(long unsigned int x) {cout << x << End_Of_Stream;}
void print(long long x) {cout << x << End_Of_Stream;}
void print(unsigned long long x) {cout << x << End_Of_Stream;}
void print(float x) {cout << x << End_Of_Stream;}
void print(double x) {cout << x << End_Of_Stream;}
void print(long double x) {cout << x << End_Of_Stream;}
void print(char x) {cout << x << End_Of_Stream;}
void print(const char* x) {cout << x << End_Of_Stream;}
void print(string x) {cout << x << End_Of_Stream;}
void print(bool x) {cout << x << End_Of_Stream;}
template <typename T1, typename T2> void print(pair <T1, T2> a) {cout << a.first << " " << a.second << End_Of_Stream;}
template <size_t sz> void print(bitset<sz> a) {
for(int i = 0; i < sz; i++){
cout << a[i];
}
cout << End_Of_Stream;
}
template <typename T> void write(T x) {print(x);}
template <class T, class... Ts> void write(T t, Ts... ts){
write(t);
write(ts...);
}
template <class T, class... Ts> void print(T t, Ts... ts){
End_Of_Stream = ' ';
write(t, ts...);
cout << '\n';
End_Of_Stream = '\n';
}
template <typename T> void print(T a){
for(auto it : a){
print(it);
}
}
template <class T, class... Ts> void prine(T t, Ts... ts){
print(t, ts...);
exit(0);
}
}
using namespace Output;
typedef pair <long long, int> pii;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
const int INF = 1e9 + 10;
const long long INFL = 1e18;
const int MOD = 1e9 + 7;
const int N = 2e5 + 10;
long long sum[N];
int main()
{
setIO();
int T;
cin >> T;
while (T--){
int n, m;
cin >> n >> m;
long long mx = 0;
vector<pii> ans;
for(int i = 1; i <= n; i++){
int x;
cin >> x;
sum[i] = sum[i - 1] + x;
if (sum[i] > mx){
mx = sum[i];
ans.push_back({sum[i], i - 1});
}
}
End_Of_Stream = ' ';
while (m--){
long long x;
cin >> x;
if (sum[n] <= 0){
int res = position(ans.begin(), ans.end(), pii(x, -1));
print(res == ans.size() ? -1 : ans[res].second);
} else {
int l = 0;
int r = INF / sum[n] + 10;
while (l < r){
int mid = (l + r) >> 1;
long long S = 1LL * sum[n] * mid;
if (S + mx < x){
l = mid + 1;
} else {
r = mid;
}
}
if (r == INF / sum[n] + 10){
print(-1);
continue;
}
long long S = 1LL * sum[n] * r;
x -= S;
if (x <= 0){
print(1LL * r * n);
continue;
}
int res = position(ans.begin(), ans.end(), pii(x, -1));
print(ans[res].second + 1LL * r * n);
}
}
End_Of_Stream = '\n';
print("");
}
return 0;
}
| 13 |
CPP
|
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def S(): return input().strip()
def print_list(l):
print(' '.join(map(str, l)))
# sys.setrecursionlimit(100000)
# import random
# from functools import reduce
# from functools import lru_cache
# from heapq import *
# from collections import deque as dq
import math
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
def find(x, now):
if tree[now] < x: return -1
if now >= nn: return now - nn
t = find(x, now << 1)
if t >= 0: return t
return find(x, now << 1 | 1)
for _ in range(N()):
n, _ = RL()
a, x = RLL(), RLL()
s = [0]
for v in a: s.append(s[-1] + v)
nn = 1 << (n + 1).bit_length()
tree = [0] * nn + s + [0] * (nn - n - 1)
for i in range(nn - 1, 0, -1):
tree[i] = max(tree[i << 1], tree[i << 1 | 1])
ans = []
for v in x:
if s[-1] <= 0 and tree[1] < v:
ans.append(-1)
continue
k = 0 if v <= tree[1] else math.ceil((v - tree[1]) / s[-1])
ans.append(k * n + find(v - k * s[-1], 1) - 1)
print_list(ans)
| 13 |
PYTHON3
|
#include <iostream>
#include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define int long long
#define all(a) a.begin(), a.end()
#define forn(i, N) for (int i = 0; i < N; i++)
#define forab(i, a, b) for (int i = a; i < b; i++)
#define print(x) \
for (auto i : x) \
cout << i << ' '; \
cout << endl;
using namespace std;
int N, i, T, M, a, b, c, d;
int give_time(int val, vector<int> &max_A)
{
return lower_bound(all(max_A), val) - max_A.begin();
}
int give_time(int val, int sigma, int mx, vector<int> &A, vector<int> &max_A)
{
if (sigma <= 0)
{
if (val > mx)
return -1;
return give_time(val, max_A);
}
int n;
if (val <= mx)
n = 0;
else
n = ceil(double((val - mx)) / double(sigma));
val -= n * sigma;
return give_time(val, max_A) + n * A.size();
}
void solve()
{
cin >> N >> M;
vector<int> A(N);
vector<int> X(M);
vector<int> max_A(N);
for (int &i : A)
cin >> i;
for (int &i : X)
cin >> i;
int sig = 0;
int mx = INT_MIN;
int index = 0;
for (int i : A)
{
sig += i;
mx = max(mx, sig);
max_A[index++] = mx;
}
for (int i : X)
{
cout << give_time(i, sig, mx, A, max_A) << " ";
}
cout << endl;
}
int32_t main()
{
IOS;
cin >> T;
while (T--)
solve();
return 0;
}
| 13 |
CPP
|
from collections import defaultdict,OrderedDict,Counter
from sys import stdin,stdout
from bisect import bisect_left,bisect_right
# import numpy as np
from queue import Queue,PriorityQueue
from heapq import heapify,heappop,heappush
from statistics import median,mean
from math import gcd,sqrt,floor,factorial,ceil,log2,log10,log
import fractions
import copy
from copy import deepcopy
import sys
import io
sys.setrecursionlimit(10**8)
import math
import os
import bisect
import collections
mod=pow(10,9)+7
import random
from random import random,randint,randrange
from time import time;
def ncr(n, r, p=mod):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def normalncr(n,r):
r=min(r,n-r)
count=1;
for i in range(n-r,n+1):
count*=i;
for i in range(1,r+1):
count//=i;
return count
inf=float("inf")
adj=defaultdict(set)
visited=defaultdict(int)
def addedge(a,b):
adj[a].add(b)
adj[b].add(a)
def bfs(v):
q=Queue()
q.put(v)
visited[v]=1
while q.qsize()>0:
s=q.get_nowait()
print(s)
for i in adj[s]:
if visited[i]==0:
q.put(i)
visited[i]=1
def dfs(v,visited):
if visited[v]==1:
return;
visited[v]=1
print(v)
for i in adj[v]:
dfs(i,visited)
# a9=pow(10,6)+10
# prime = [True for i in range(a9 + 1)]
# def SieveOfEratosthenes(n):
# p = 2
# while (p * p <= n):
# if (prime[p] == True):
# for i in range(p * p, n + 1, p):
# prime[i] = False
# p += 1
# SieveOfEratosthenes(a9)
# prime_number=[]
# for i in range(2,a9):
# if prime[i]:
# prime_number.append(i)
def reverse_bisect_right(a, x, lo=0, hi=None):
if lo < 0:
raise ValueError('lo must be non-negative')
if hi is None:
hi = len(a)
while lo < hi:
mid = (lo+hi)//2
if x > a[mid]:
hi = mid
else:
lo = mid+1
return lo
def reverse_bisect_left(a, x, lo=0, hi=None):
if lo < 0:
raise ValueError('lo must be non-negative')
if hi is None:
hi = len(a)
while lo < hi:
mid = (lo+hi)//2
if x >= a[mid]:
hi = mid
else:
lo = mid+1
return lo
def get_list():
return list(map(int,input().split()))
def get_str_list_in_int():
return [int(i) for i in list(input())]
def get_str_list():
return list(input())
def get_map():
return map(int,input().split())
def input_int():
return int(input())
def matrix(a,b):
return [[0 for i in range(b)] for j in range(a)]
def swap(a,b):
return b,a
def find_gcd(l):
a=l[0]
for i in range(len(l)):
a=gcd(a,l[i])
return a;
def is_prime(n):
sqrta=int(sqrt(n))
for i in range(2,sqrta+1):
if n%i==0:
return 0;
return 1;
def prime_factors(n):
sqrta = int(sqrt(n))
for i in range(2,sqrta+1):
if n%i==0:
return [i]+prime_factors(n//i)
return [n]
def p(a):
if type(a)==str:
print(a+"\n")
else:
print(str(a)+"\n")
def ps(a):
if type(a)==str:
print(a)
else:
print(str(a))
def kth_no_not_div_by_n(n,k):
return k+(k-1)//(n-1)
nc="NO"
yc="YES"
ns="No"
ys="Yes"
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# input=stdin.readline
# print=stdout.write
t=int(input())
for i in range(t):
n,m=get_map();
a=get_list();
x=get_list();
suma=sum(a)
prefix=[0 for i in range(n)]
maxa=[0 for i in range(n)]
for i in range(n):
prefix[i]=a[i]
maxa[i]=prefix[i]
if i:
prefix[i]+=prefix[i-1]
maxa[i]=max(prefix[i],maxa[i-1])
# print(maxa)
if suma<=0:
for i in x:
indexa=bisect_left(maxa,i)
if indexa==n:
print(-1,end=" ")
else:
print(indexa,end=" ")
else:
for i in x:
count=0;
if i>maxa[-1]:
if i%suma==0:
count=ceil((i-maxa[-1])/(suma))
i=i-count*suma
else:
count=ceil((i-maxa[-1])/(suma))
i = i - count * suma
indexa=bisect_left(maxa,i)
print(count*n+indexa,end=" ")
print('')
# 1
# 2 2
# 2 -1
# 2 1
# 1
# 9 5
# 5 5 5 5 5 -5 -5 -5 -5
# 26 27 28 29 30
# 45 45 45 45 45
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define codefor int test;scanf("%d",&test);while(test--)
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define yes(ans) if(ans)printf("yes\n");else printf("no\n")
#define Yes(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YES(ans) if(ans)printf("YES\n");else printf("NO\n")
#define vector1d(type,name,...) vector<type>name(__VA_ARGS__)
#define vector2d(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
const int MOD=1000000007;
const int MOD2=998244353;
const int INF=1<<30;
const ll INF2=(ll)1<<60;
//入力系
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T,class L>void scan(pair<T, L>& p){scan(p.first);scan(p.second);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
//出力系
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T,class L>void print(const pair<T, L>& p){print(p.first);putchar(' ');print(p.second);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
//デバッグ系
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }
ll modpow(ll a, ll b, ll p){ ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
ll updivide(ll a,ll b){if(a%b==0) return a/b;else return (a/b)+1;}
template<class T> void chmax(T &a,const T b){if(b>a)a=b;}
template<class T> void chmin(T &a,const T b){if(b<a)a=b;}
int main(){
codefor{
INT(n,m);
ll minv=0,cycle,l,r,mid,index;
vector<ll> a(n),b(m),sumv(n,0),ans(m,-1);
in(a,b);
sumv[0]=a[0];
for(int i=1;i<n;i++){
sumv[i]=sumv[i-1]+a[i];
}
cycle=sumv[n-1];
minv=a[0];
for(int i=0;i<n;i++){
chmax(sumv[i],minv);
chmax(minv,sumv[i]);
}
rep(i,m){
mid=(lower_bound(all(sumv),b[i])-sumv.begin());
if(mid<n){
ans[i]=mid;
continue;
}else if(cycle<=0){
continue;
}
l=0,r=(INF2/(16*cycle));
ans[i]=INF2;
while(l<r){
mid=(l+r)/2;
index=(lower_bound(all(sumv),b[i]-cycle*mid)-sumv.begin());
if(index<n){
if(mid<=INF2/n)chmin(ans[i],(ll)index+n*mid);
r=mid;
}else l=mid+1;
}
/*debug("{",l);
ans[i]=(lower_bound(all(sumv),b[i]-cycle*(l-1))-sumv.begin())+(l-1)*n;*/
}
out(ans);
}
}
| 13 |
CPP
|
#include <bits/stdc++.h>
#define pb push_back
typedef long long ll;
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector <ll> vec(n);
vector <pair<ll, int>> add;
ll sum1 = 0, sum2 = 0;
for (int i = 0; i < n; ++i) {
cin >> vec[i];
sum1 += vec[i];
if (sum1 > sum2) {
add.pb({sum1, i});
sum2 = sum1;
}
}
vector <ll> add2;
for (auto it : add)
add2.pb(it.first);
while (m--) {
ll x;
cin >> x;
int pos = lower_bound(add2.begin(), add2.end(), x) - add2.begin();
if (pos < add2.size())
cout << add[pos].second << " ";
else {
if (sum1 <= 0)
cout << -1 << " ";
else {
ll l = 1, r = 2e9;
ll ans2 = -1;
while (l <= r){
ll mid = (l + r) >> 1;
ll temp = x - mid * sum1;
ll ans = n * mid - 1;
bool f = true;
if (temp > 0){
int pos = lower_bound(add2.begin(), add2.end(), temp) - add2.begin();
if (pos < add2.size())
ans += add[pos].second + 1;
else
f = false;
}
if (f){
ans2 = ans;
r = mid - 1;
}
else
l = mid + 1;
}
cout << ans2 << " ";
}
}
}
cout << endl;
}
}
| 13 |
CPP
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+50;
ll n,m,T,a[maxn],sum[maxn],maxx[maxn],ans[maxn];
int main(){
cin>>T;
while(T--){
cin>>n>>m;
for(int i=1;i<=n;i++)cin>>a[i],sum[i]=sum[i-1]+a[i],maxx[i]=max(maxx[i-1],sum[i]);
for(int i=1;i<=m;i++){
ll x;cin>>x;
if(x<=maxx[n]){
cout<<lower_bound(maxx+1,maxx+1+n,x)-maxx-1<<' ';
}
else{
if(sum[n]<=0){
cout<<-1<<' ';
}
else{
ll d=x-maxx[n];
ll tot=ceil(d*1.0/sum[n]);
x-=tot*sum[n];
ll t=lower_bound(maxx+1,maxx+1+n,x)-maxx;
t=t+tot*n-1;
cout<<t<<' ';
}
}
}
cout<<endl;
}
return 0;
}
| 13 |
CPP
|
import sys
input=sys.stdin.readline
from bisect import bisect_left
def getans(a,x,n,ma,s,ss,ssi):
p=ma
if s>0:
cnt=0
if x<=ma:
return ssi[bisect_left(ss,x)]
if x>ma:
cnt=(x-ma)//s
p+=cnt*s
while(1):
if x<=p:
return n*cnt+ssi[bisect_left(ss,x-cnt*s)]
p+=s
cnt+=1
if s<=0:
if x<=p:
return ssi[bisect_left(ss,x)]
return -1
for _ in range(int(input())):
n,m=[*map(int,input().split())]
a=[*map(int,input().split())]
b=[*map(int,input().split())]
s=a[0]
ss=[a[0]]
ssi=[0]
for i in range(1,n):
s+=a[i]
if s>ss[-1]:
ss.append(s)
ssi.append(i)
ma=ss[-1]
for i in range(m):
print(getans(a,b[i],n,ma,s,ss,ssi),end=' ')
| 13 |
PYTHON3
|
# from __future__ import print_function,division
# range = xrange
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10**9)
from sys import stdin, stdout
from collections import defaultdict, Counter
M = 10**9+7
def main():
for _ in range(int(input())):
n,m = [int(s) for s in input().split()]
l = [int(s) for s in input().split()]
q = [int(s) for s in input().split()]
s = sum(l)
ma = -10**9-7
curr = 0
for i in range(n):
curr+=l[i]
ma = max(curr,ma)
ans = [-1]*m
qs = []
for i in range(m):
if q[i]>ma:
if s<=0:
continue
else:
w = ((q[i]-ma)//s)*s
ans[i] = n*((q[i]-ma)//s)
if w+ma<q[i]:
w+=s
ans[i]+=n
qs.append([q[i]-w,i])
else:
ans[i] = 0
qs.append([q[i],i])
qs.sort()
j = 0
curr = 0
# print(ans)
for i in range(n):
curr+=l[i]
while j<len(qs) and qs[j][0]<=curr:
ans[qs[j][1]]+=i
j+=1
print(*ans)
if __name__== '__main__':
main()
| 13 |
PYTHON3
|
t = int(input())
for __ in range(t):
n, m = map(int, input().split(' '))
arr = [int(val) for val in input().split(' ')]
x = [int(val) for val in input().split(' ')]
stack = []
csum = 0
cmax = 0
for a in arr:
csum += a
cmax = max(cmax, csum)
stack.append(cmax)
res = [0]*m
for i, y in enumerate(x):
if csum <= 0:
if y > cmax:
res[i] = -1
else:
left = 0
right = len(stack)
while left < right:
mid = (left+right)//2
if stack[mid] >= y:
right = mid
else:
left = mid+1
res[i] = left
else:
num_req = max(0,(y-stack[-1]+csum-1) // csum)
left = 0
right = len(stack)
while left < right:
mid = (left+right)//2
if stack[mid] >= y-csum*num_req:
right = mid
else:
left = mid+1
res[i] = num_req*n+left
print(' '.join(map(str,res)))
| 13 |
PYTHON3
|
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
//read domain
typedef long long ll;
int dp[200001][2];
void build(int l, int r, vector<int> const &a, vector<int> &d, int curD = 0) {
if (r < l) {
return;
}
if (l == r) {
d[l] = curD;
return;
}
int m = l;
for (int i = l + 1; i <= r; i++) {
if (a[m] < a[i]) {
m = i;
}
}
d[m] = curD;
build(l, m - 1, a, d, curD + 1);
build(m + 1, r, a, d, curD + 1);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
// cout << "hh" << endl;
freopen("new_inp2.txt", "r", stdin);
freopen("okk.txt", "w", stdout);
#endif
ll chk[10001];
int t;
cin >> t;
while (t--)
{ //cout << "yes" << endl;
ll n, m;
cin >> n >> m;
set<pair<ll, ll>> st;
vector<ll> vect;
ll sum = 0, mxx = INT_MIN;
for (int i = 0; i < n; i++)
{
int x;
cin >> x;
vect.push_back(x);
sum += x;
if (mxx < sum)
{
mxx = sum;
st.insert({sum, i});
// cout << sum << " " << i << endl;
}
}
// for (auto i : vect)
// {
// cout << i << " ";
// }
// cout << endl;
//cout << "yo" << endl;
while (m--)
{
ll x;
cin >> x;
// cout << st.size() << "I am" << x << endl;
ll round = 0;
if (sum <= 0 && st.rbegin()->first < x)
{
cout << "-1" << " ";
continue;
}
if (mxx < x)
{
ll temp = x - mxx;
round = temp / sum + (temp % sum == 0 ? 0 : 1);
x -= round * sum;
}
auto index = st.lower_bound({x, -1});
//cout << round << "dd" << x << " " << index->second << endl;
cout << index->second + round*n << " ";
}
cout << endl;
}
}
| 13 |
CPP
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Codeforces Round #702 (Div. 3)
Problem G. Old Floppy Drive
:author: Kitchen Tong
:mail: [email protected]
Please feel free to contact me if you have any question
regarding the implementation below.
"""
__version__ = '3.2'
__date__ = '2021-03-14'
import sys
from bisect import bisect_left
from itertools import accumulate
def solve(n, m, a, x):
p = list(accumulate(a))
s = p[-1]
for i in range(1, n):
p[i] = max(p[i], p[i-1])
ans = list()
for i in range(m):
if s <= 0 and x[i] > p[-1]:
ans.append(-1)
continue
elif s <= 0 or x[i] <= p[-1]:
k = 0
else:
k = (x[i] - p[-1]) // s
if (x[i] - p[-1]) % s > 0:
k += 1
x[i] -= k * s
index = bisect_left(p, x[i])
ans.append(k * n + index)
return ans
def main(argv=None):
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
a = list(map(int, input().split()))
x = list(map(int, input().split()))
print(' '.join(map(str, solve(n, m, a, x))))
return 0
if __name__ == "__main__":
STATUS = main()
sys.exit(STATUS)
| 13 |
PYTHON3
|
from random import random, randint, randrange
from time import time
import random
import collections
import bisect
import os
import math
from collections import defaultdict, OrderedDict, Counter
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
from queue import Queue, PriorityQueue
from heapq import heapify, heappop, heappush
from statistics import median, mean
from math import gcd, sqrt, floor, factorial, ceil, log2, log10, log
import fractions
import copy
from copy import deepcopy
import sys
import io
sys.setrecursionlimit(10**8)
mod = pow(10, 9)+7
def ncr(n, r, p=mod):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def normalncr(n, r):
r = min(r, n-r)
count = 1
for i in range(n-r, n+1):
count *= i
for i in range(1, r+1):
count //= i
return count
inf = float("inf")
adj = defaultdict(set)
visited = defaultdict(int)
def addedge(a, b):
adj[a].add(b)
adj[b].add(a)
def bfs(v):
q = Queue()
q.put(v)
visited[v] = 1
while q.qsize() > 0:
s = q.get_nowait()
print(s)
for i in adj[s]:
if visited[i] == 0:
q.put(i)
visited[i] = 1
def dfs(v, visited):
if visited[v] == 1:
return
visited[v] = 1
print(v)
for i in adj[v]:
dfs(i, visited)
def reverse_bisect_right(a, x, lo=0, hi=None):
if lo < 0:
raise ValueError('lo must be non-negative')
if hi is None:
hi = len(a)
while lo < hi:
mid = (lo+hi)//2
if x > a[mid]:
hi = mid
else:
lo = mid+1
return lo
def reverse_bisect_left(a, x, lo=0, hi=None):
if lo < 0:
raise ValueError('lo must be non-negative')
if hi is None:
hi = len(a)
while lo < hi:
mid = (lo+hi)//2
if x >= a[mid]:
hi = mid
else:
lo = mid+1
return lo
def get_list():
return list(map(int, input().split()))
def get_str_list_in_int():
return [int(i) for i in list(input())]
def get_str_list():
return list(input())
def get_map():
return map(int, input().split())
def input_int():
return int(input())
def matrix(a, b):
return [[0 for i in range(b)] for j in range(a)]
def swap(a, b):
return b, a
def find_gcd(l):
a = l[0]
for i in range(len(l)):
a = gcd(a, l[i])
return a
def is_prime(n):
sqrta = int(sqrt(n))
for i in range(2, sqrta+1):
if n % i == 0:
return 0
return 1
def prime_factors(n):
sqrta = int(sqrt(n))
for i in range(2, sqrta+1):
if n % i == 0:
return [i]+prime_factors(n//i)
return [n]
def p(a):
if type(a) == str:
print(a+"\n")
else:
print(str(a)+"\n")
def ps(a):
if type(a) == str:
print(a)
else:
print(str(a))
def kth_no_not_div_by_n(n, k):
return k+(k-1)//(n-1)
nc = "NO"
yc = "YES"
ns = "No"
ys = "Yes"
t = int(input())
for i in range(t):
n, m = get_map()
a = get_list()
x = get_list()
suma = sum(a)
prefix = [0 for _ in range(n)]
maxa = [0 for _ in range(n)]
for i in range(n):
prefix[i] = a[i]
maxa[i] = prefix[i]
if i:
prefix[i] += prefix[i-1]
maxa[i] = max(prefix[i], maxa[i-1])
# print(maxa)
if suma <= 0:
for i in x:
indexa = bisect_left(maxa, i)
if indexa == n:
print(-1, end=" ")
else:
print(indexa, end=" ")
else:
for i in x:
count = 0
if i <= maxa[-1]:
indexa = bisect_left(maxa, i) + 1
else:
count = ceil((i - maxa[-1])/suma)
i = i - suma * count
indexa = 0
if i != 0:
indexa = bisect_left(maxa, i) + 1
print(count * n + indexa - 1, end=" ")
print('')
# 1
# 2 2
# 2 -1
# 2 1
# 2 2
# 2 0
# 1 2
# 0 1
| 13 |
PYTHON3
|
from bisect import bisect_right
for _ in range(int(input())):
n, m = map(int,input().split())
arr = list(map(int,input().split()))
queries = list(map(int,input().split()))
cum = [0] * n
cum[0] = arr[0]
total = arr[0]
for i in range(1,n):
total += arr[i]
cum[i] = max(cum[i-1], total)
res = [0] * m
if total <= 0:
for i,x in enumerate(queries):
if x > cum[-1]:
res[i] = -1
else:
j = bisect_right(cum, x-1)
res[i] = j
else:
for i,x in enumerate(queries):
if x <= cum[-1]:
j = bisect_right(cum, x-1)
res[i] = j
else:
a = x - cum[-1]
q = (a + total - 1) // total
r = x - q * total
j = bisect_right(cum, r - 1)
res[i] = n * q + j
print(*res)
| 13 |
PYTHON3
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int arr[200005];
ll nax,nim;
int n,m;
ll max(ll a,ll b){
return (a<b)?b:a;
}
ll min(ll a,ll b){
return (a<b)?a:b;
}
int main(){
int t;cin>>t;
while(t--){
cin>>n>>m;
ll nax=LONG_MIN;
ll s=0;
set<pair<ll,ll>> record;
for(int i=1;i<=n;i++){
cin>>arr[i];
s+=arr[i];
if(s>nax){
nax=s;
record.insert(make_pair(nax,i-1));
}
}
while(m--){
int x;cin>>x;
if(s<=0&&x>nax){
cout<<"-1 ";continue;
}
int round=0;
if(nax<x){
int k=x-nax+s-1;
round=k/s;
x=x-round*s;
}
auto k=record.lower_bound(make_pair(x,-1));
cout<<round*1ll*n+(*k).second<<" ";
}
cout<<"\n";
}
}
| 13 |
CPP
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#pragma GCC optimize("O2", "O3", "fast")
#define _9trash no WA
#define ll long long
#define pb push_back
void io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
// -------------------------------------------------------------
ll n, x, a[200010], sum, mx;
ll cur, cnt, re;
vector<pair<int, ll>> v;
ll solve() {
if (x > mx && sum <= 0)
return -1;
cur = cnt = 0;
if (x > mx)
cnt = (x - mx + sum - 1) / sum;
re = x - cnt * sum;
int l = 0, r = v.size();
while (l < r) {
int mid = (l + r) / 2;
if (v[mid].second >= re)
r = mid;
else
l = mid + 1;
}
return cnt * n + v[l].first;
}
int t, m;
signed main() {
io();
cin >> t;
while (t--) {
v.clear();
cin >> n >> m;
sum = 0, mx = -2e9;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
if (sum > mx) {
mx = sum;
v.pb({i, mx});
}
}
for (int i = 0; i < m; i++) {
cin >> x;
cout << solve() << " ";
}
cout << "\n";
}
return 0;
}
| 13 |
CPP
|
t = int(input())
xs = []
pref = []
n = 0
class SegmentTree:
def __init__(self, n):
self.t = [0 for _ in range(n * 4)]
def Build(self, v, tl, tr):
if tl + 1 == tr:
self.t[v] = pref[tl]
else:
tm = (tl + tr) >> 1
self.Build(v * 2 + 1, tl, tm)
self.Build(v * 2 + 2, tm, tr)
self.t[v] = max(self.t[v * 2 + 1], self.t[v * 2 + 2])
def Get(self, v, tl, tr, l, r, val):
if tl >= r or tr <= l or self.t[v] < val:
return -1
if tl + 1 == tr:
return tl
else:
tm = (tl + tr) >> 1
res = self.Get(v * 2 + 1, tl, tm, l, r, val)
if res == -1:
return self.Get(v * 2 + 2, tm, tr, l, r, val)
return res
tree = SegmentTree(0)
def FindPos(val):
return tree.Get(0, 0, n, 0, n, val)
for _ in range(t):
n, m = list(map(int ,input().split()))
a = list(map(int,input().split()))
xs = list(map(int,input().split()))
pref = [a[i] for i in range(n)]
for i in range(1, n):
pref[i] += pref[i - 1]
tree = SegmentTree(n)
tree.Build(0, 0, n)
dlt = pref[-1]
INF = 5 * 10 ** 9
if dlt <= 0:
for x in xs:
pos = FindPos(x)
print(pos, end = ' ')
print()
else:
mx = max(pref)
for x in xs:
k = max(0, (x - mx + dlt - 1) // dlt)
ans = k * n
x -= k * dlt
ans += FindPos(x)
print(ans, end = ' ')
print()
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
#define pb push_back
#define fi first
#define se second
#define all(X) (X).begin(),(X).end()
#define ln "\n"
#define out cout
#define NON_TOGLIERE ios_base::sync_with_stdio(0); cin.tie(0);
#define ll long long
#define VI vector<int>
#define pii pair<int,int>
#define pll pair<long long,long long>
#define PQ priority_queue
#define sz(v) ((int)v.size())
#define inf 1000000001
#define maxn 200010
using namespace std;
#if ONLINE_JUDGE
#define in cin
#else
ifstream in("input.txt");
#endif
ll n,i,Q,T,j,k,m,t,x,y,mam,v[maxn],s[maxn],q[maxn],p[maxn];
int main(){
NON_TOGLIERE
in>>Q;
for(T=1;T<=Q;T++){
in>>n>>m;mam=0;ll fine=0;
vector<pll>kek;
for(i=0;i<n;i++)in>>v[i];
s[0]=mam=v[0];
if(v[0]>0)kek.pb({v[0],0ll});
for(i=1;i<n;i++){
s[i]=v[i]+s[i-1];
if(s[i]>mam){
mam=s[i];
kek.pb({mam,i});
}
}
//for(auto y:kek)cout<<y.fi<<" ";out<<ln;
for(i=0;i<m;i++){
fine=0;
in>>x;
if(x>mam&&s[n-1]<=0){
cout<<-1<<" ";continue;
}
if(x>mam){//cout<<x<<ln;
k=x-mam;
k=(k-1+s[n-1])/s[n-1];
x-=k*s[n-1];
fine+=n*k;
}
if(x==0){
cout<<fine<<" "; continue;
}
pll tmp={x,0ll};
auto ind=lower_bound(all(kek),tmp);
int cel=(int)(ind-kek.begin());
fine+=kek[cel].se;
cout<<fine<<" ";
}
out<<ln;
}
}
| 13 |
CPP
|
#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef long long LL;
const int N = 200010;
int n, m;
LL a[N];
LL s[N];
struct Stack
{
LL s, id;
}stk[N];
int main()
{
int t;
cin >> t;
while (t -- )
{
cin >> n >> m;
LL maxv = 0, sum = 0;
for (int i = 1; i <= n; i ++ )
{
cin >> a[i];
sum += a[i];
s[i] = s[i - 1] + a[i];
if (i != n) maxv = max(maxv, s[i]);
}
int tt = 0;
for (int i = 0; i <= n - 1; i ++ )
{
if (!tt || stk[tt].s < s[i]) stk[ ++ tt] = {s[i], i};
}
while (m -- )
{
LL x;
cin >> x;
if (maxv < x && sum <= 0)
{
cout << -1 << ' ';
continue;
}
LL T = 0;
if (sum > 0) T = max(T, (x - maxv + sum - 1) / sum);
x -= T * sum;
int l = 1, r = tt;
while (l < r)
{
int mid = l + r >> 1;
if (stk[mid].s >= x) r = mid;
else l = mid + 1;
}
cout << ((LL)T * n + stk[l].id - 1) << ' ';
}
cout << endl;
}
return 0;
}
| 13 |
CPP
|
//#include <atcoder/all>
//using namespace atcoder;
//using mint = modint;
#include <bits/stdc++.h>
#define int long long
#define sint signed
#define endl "\n" // fflush(stdout);
#define ALL(v) (v).begin(),(v).end()
#define Vi vector<int>
#define VVi vector<Vi>
#define VVVi vector<VVi>
#define Vm vector<mint>
#define VVm vector<Vm>
#define Vs vector<string>
#define Vd vector<double>
#define Vc vector<char>
#define Pii pair<int,int>
#define Pdd pair<double,double>
#define VPii vector<Pii>
#define Tiii tuple<int,int,int>
#define VTiii vector<Tiii>
#define PQi priority_queue<int>
#define PQir priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define itos to_string
#define stoi stoll
#define FI first
#define SE second
#define cYES cout<<"YES"<<endl
#define cNO cout<<"NO"<<endl
#define cYes cout<<"Yes"<<endl
#define cNo cout<<"No"<<endl
#define cyes cout<<"yes"<<endl
#define cno cout<<"no"<<endl
#define sortr(v) sort(v,greater<>())
#define rep(i,a,b) for(int i=a;i<b;i++)
#define repeq(i,a,b) for(int i=a;i<=b;i++)
#define repreq(i,a,b) for(int i=a;i>=b;i--)
#define dem(a,b) ((a+b-1)/(b))
#define INF 3000000000000000000 // 3.0*10^18
#define MAX LLONG_MAX
#define PI acos(-1.0L)
using namespace std;
/* debug */
template <typename T>
ostream& operator<<(ostream& os,const vector<T> &V){int N=V.size();
if(N==0){os<<'.';return os;}rep(i,0,N-1){os<<V[i]<<' ';}os<<V[N-1];return os;}
template <typename T>
ostream& operator<<(ostream& os,const vector<vector<T>> &V){
int N=V.size();rep(i,0,N-1)os<<V[i]<<endl;os<<V[N-1];return os;}
template <typename T,typename S>
ostream& operator<<(ostream& os, pair<T,S> const&P){os<<P.FI<<' '<<P.SE;return os;}
//ostream& operator<<(ostream& os, mint const&M){os<<M.val();return os;}
/* useful */
template<typename T>void Vin(vector<T> &v){int n=v.size();rep(i,0,n)cin>>v[i];}
int scomb(int n, int r){if(r<0||r>n)return 0;if((n-r)<r)r=n-r; // nCr
int a=1;for(int i=n;i>n-r;--i){a=a*i;}for(int i=1;i<r+1;++i){a=a/i;}return a;}
int digit_sum(int n){int ret=0; while(n>0){ret+=n%10;n/=10;}return ret;}
int digit(int k,int i){string s = itos(k);return s[s.size()-i]-'0';}
template<typename T>void press(T &v){v.erase(unique(ALL(v)),v.end());}
int SMALLER(Vi &a,int x){return lower_bound(a.begin(),a.end(),x)-a.begin();}
int orSMALLER(Vi &a,int x){return upper_bound(a.begin(),a.end(),x)-a.begin();}
int BIGGER(Vi &a,int x){return a.size()-orSMALLER(a,x);}
int orBIGGER(Vi &a,int x){return a.size()-SMALLER(a,x);}
int COUNT(Vi &a,int x) {return upper_bound(ALL(a),x)-lower_bound(ALL(a),x);}
int maxind(Vi &a){return max_element(ALL(a))-a.begin();}
int minind(Vi &a){return min_element(ALL(a))-a.begin();}
template<typename T>bool chmax(T &a,T b) {if(a<b){a=b;return 1;}return 0;}
template<typename T>bool chmin(T &a,T b) {if(a>b){a=b;return 1;}return 0;}
/*
Vi zip(Vi b){int Z=b.size();
Pii p[Z+10];int a=b.size();Vi l(a);for(int i=0;i<a;i++)
p[i]=mp(b[i],i);sort(p,p+a);int w=0;for(int i=0;i<a;i++)
{if(i&&p[i].first!=p[i-1].first)w++;l[p[i].second]=w;}return l;}
*/
Vi vis(Vi &v){Vi S(v.size()+1);rep(i,1,S.size())S[i]+=v[i-1]+S[i-1];return S;}
//const int MOD = 998244353;
const int MOD = 1000000007;
const double EPS = 1e-10;
void init(){cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
cout<<fixed<<setprecision(12);//mint::set_mod(MOD);
}
/************************************ START ************************************/
void sol() {
int n,m;cin >> n >> m;
Vi a(n),x(m);Vin(a);Vin(x);
int sum = 0;
rep(i,0,n) {
sum += a[i];
}
Vi b = vis(a);
int maxx = -INF;
rep(i,0,b.size()) {
chmax(maxx,b[i]);
b[i] = maxx;
}
//cout << b << endl;
Vi pre(m);
rep(i,0,m) {
if(sum <= 0) {
int ans = SMALLER(b,x[i]);
if(ans > n) pre[i] = -1;
else pre[i] = ans-1;
}
else {
int ans = 0;
int kai = 0,sa = 0;
if(x[i] > maxx) {
sa = x[i]-maxx;
kai = dem(sa,sum);
ans += kai*n;
x[i] -= kai*sum;
}
ans += SMALLER(b,x[i])-1;
pre[i] = ans;
}
}
cout << pre << endl;
}
signed main() {
init();
int q = 1;
cin >> q;
while(q--) sol();
return 0;
}
| 13 |
CPP
|
import heapq
def solve(n, a, x):
delta = sum(a)
offset = [0] * len(x)
if delta > 0:
mx = None
s = 0
for i in range(n):
s += a[i]
if mx is None or mx < s:
mx = s
offset = [0] * len(x)
for i in range(len(x)):
laps = (max(0, x[i] - mx) + delta - 1) // delta
offset[i] = laps * n
x[i] -= laps * delta
q = []
for i in range(len(x)):
heapq.heappush(q, (x[i], i))
s = 0
res = [-1] * len(x)
for i in range(n):
s += a[i]
while q and s >= q[0][0]:
res[q[0][1]] = i + offset[q[0][1]]
heapq.heappop(q)
return res
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
a = list(map(int, input().split()))
x = list(map(int, input().split()))
print(*solve(n, a, x))
| 13 |
PYTHON3
|
import math
import sys
import collections
import bisect
import heapq
testcases = int(sys.stdin.readline())
for _ in range(testcases):
arr = list(map(int,sys.stdin.readline().strip().split()))
n = arr[0]
m = arr[1]
ns = list(map(int,sys.stdin.readline().strip().split()))
ms = list(map(int,sys.stdin.readline().strip().split()))
subs = [0]*n
mx = 0
s = 0
improves = []
imp = []
for i,j in enumerate(ns):
s += j
subs[i] = s
if s > mx:
mx = s
improves.append((s,i))
imp.append(s)
#print(subs)
#print(improves)
#print(imp)
for m in ms:
#print("output", m)
if subs[-1] <= 0 and m > mx:
print(-1,end=" ")
continue
else:
res = 0
x = m - mx
#print(x, "x")
if x > 0:
res = math.ceil(x/subs[-1])*len(ns)
m -= math.ceil(x/subs[-1])*subs[-1]
#print(m, "m")
ind = bisect.bisect_left(imp,m)
#print(ind, "ind")
res += improves[ind][1]
print(res, end = " ")
print("")
| 13 |
PYTHON3
|
t = int(input())
for _ in range(t):
n, m = list(map(int ,input().split()))
a = list(map(int,input().split()))
xs = list(map(int,input().split()))
pref = [a[i] for i in range(n)]
pref_max = [a[i] for i in range(n)]
for i in range(1, n):
pref[i] += pref[i - 1]
pref_max[i] = max(pref[i], pref_max[i - 1])
dlt = pref[-1]
ans = []
if dlt <= 0:
for x in xs:
l = 0
r = n - 1
m = 0
res = n
while l <= r:
m = (l + r) >> 1
if pref_max[m] >= x:
res = m
r = m - 1
else:
l = m + 1
if res == n:
res = -1
ans.append(str(res))
else:
mx = max(pref)
for x in xs:
k = max(0, (x - mx + dlt - 1) // dlt)
x -= k * dlt
l = 0
r = n - 1
m = 0
res = n
while l <= r:
m = (l + r) >> 1
if pref_max[m] >= x:
res = m
r = m - 1
else:
l = m + 1
ans.append(str(k * n + res))
print(' '.join(ans))
| 13 |
PYTHON3
|
from math import ceil
from bisect import bisect_left
def find():
n, m = map(int, input().split())
sum_a = 0
pref = {}
pref_s = [0]
ind = 0
for j in input().split():
sum_a += int(j)
if sum_a not in pref:
pref[sum_a] = ind
if sum_a > pref_s[-1]:
pref_s.append(sum_a)
ind += 1
for j in input().split():
j = int(j)
ans = 0
if j <= pref_s[-1]:
my_pref = j
else:
if sum_a <= 0:
print(-1, end=' ')
continue
else:
tmp = ceil((j - pref_s[-1]) / sum_a)
my_pref = max(0, j - tmp * sum_a)
ans += tmp * n
print(ans + pref[pref_s[bisect_left(pref_s, my_pref, lo=1)]], end=' ')
print()
for i in range(int(input())):
find()
| 13 |
PYTHON3
|
//in dp prefix suffix sum helps..
#include<iostream>
#include<vector>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<stack>
#include <iterator>
#include <map>
#include<list>
#include <fstream>
#include<unordered_map>
#include<set>
#include<queue>
#define int long long
#define double long double
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define pip pair<int, pair<int, int> >
#define viv vector<vector<int> >
#define vip vector< pair<int, int> >
#define vi vector<int>
#define mii map<int, int>
#define qu queue<int>
#define set set<int>
#define multi multiset<int>
#define stack stack<int>
#define fi first
#define se second
#define reverse(s) reverse(s.begin(), s.end())
#define sort1(v) sort(v.begin(), v.end())
#define it iterator
#define pq1 priority_queue <pii, vector<pii>, greater<pii> >
#define mem(x, y) memset(x, (int)y, sizeof(x))
#define ps(x,y) fixed<<setprecision(y)<<x
// author :: Anurag Anand.
using namespace std;
int z= 1e9+7;
//int z= 998244353;
int gcd(int a, int b){
if(a==0)return b;
if(b==0)return a;
return gcd(b, a%b);
}
int power(int a,int b)
{
int res=1;
while(b)
{
if(b&1)
{
res=(res*a)%z;
b--;
}
else
{
a=(a*a)%z;
b=b>>1;
}
}
return res;
}
vi sieve;
// vi seg;
// void arrange(int i, int v, int x, int lx, int rx){
// if(rx-lx==1){
// seg[x] =v;
// return;
// }
// int m= (lx+rx)/2;
// if(i<m){
// arrange(i, v, 2*x+1, lx, m);
// }
// else arrange(i, v, 2*x+2, m, rx);
// seg[x]=seg[2*x+1]+seg[2*x+2];
// }
// int calc(int l, int r, int x, int lx, int rx){
// if(l>=rx||r<=lx) return 0;
// if(lx>=l&&rx<=r) return seg[x];
// int mid=(lx+rx)/2;
// int sl= calc(l, r, 2*x+1, lx, mid), sr= calc(l, r, 2*x+2, mid, rx);
// return sl+sr;
// }
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vi pp;
pp.assign(1000001, 0);
for(int i=2;i<1000;i++){
if(!pp[i]){
for(int j=i*i;j<=1000000;j+=i){
pp[j]=1;
}
}
}
for(int i=2;i<=1000000;i++) if(!pp[i]) sieve.pb(i);
int t;
t=1;
cin>>t;
while(t--){
int n, m;
cin>>n>>m;
int ar[n], ans[m];
for(int i=0;i<n;i++) cin>>ar[i];
for(int i=1;i<n;i++) ar[i]+=ar[i-1];
int sum=ar[n-1];
vip v;
for(int i=0;i<n;i++){
v.pb(mp(ar[i], i));
}
sort1(v);
for(int i=n-2;i>=0;i--){
if(v[i].se>v[i+1].se) v[i].se= v[i+1].se;
}
int mx=v[n-1].fi;
for(int i=0;i<m;i++){
int x;
cin>>x;
int l=0, r=n-1, a=-1;
while(l<=r){
int mid=(l+r)/2;
if(v[mid].fi>=x){
a=mid;
r= mid-1;
}
else l= mid+1;
}
if(a!=-1) ans[i]= v[a].se;
else{
if(sum<=0) ans[i]=-1;
else{
int k= (x-mx)/sum;
if((x-mx)%sum) k++;
x-=k*sum;
l=0, r=n-1, a=-1;
while(l<=r){
int mid=(l+r)/2;
if(v[mid].fi>=x){
a=mid;
r= mid-1;
}
else l= mid+1;
}
ans[i]= v[a].se+k*n;
}
}
}
for(int i=0;i<m;i++) cout<<ans[i]<<" ";
cout<<"\n";
}
}
| 13 |
CPP
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Codeforces Round #702 (Div. 3)
Problem G. Old Floppy Drive
:author: Kitchen Tong
:mail: [email protected]
Please feel free to contact me if you have any question
regarding the implementation below.
"""
__version__ = '3.0'
__date__ = '2021-03-14'
import sys
from bisect import bisect_left
def solve(n, m, a, x):
value = 0
accum_max = [-1]
for i in range(n):
value += a[i]
accum_max.append(max(accum_max[-1], value))
cycle_value = value
ans = list()
for i in range(m):
if cycle_value <= 0 and x[i] > accum_max[-1]:
ans.append(-1)
continue
if cycle_value > 0: # it takes more than 1 cycle
k_cycle = max((x[i] - accum_max[-1]), 0) // cycle_value
if max((x[i] - accum_max[-1]), 0) % cycle_value > 0:
k_cycle += 1
else: # it is within the first cycle
k_cycle = 0
x[i] -= k_cycle * cycle_value
index = bisect_left(accum_max, x[i])
ans.append(k_cycle * n + index - 1)
return ans
def main(argv=None):
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
a = list(map(int, input().split()))
x = list(map(int, input().split()))
print(' '.join(map(str, solve(n, m, a, x))))
return 0
if __name__ == "__main__":
STATUS = main()
sys.exit(STATUS)
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define t64 int64_t
#define rep(i,a,b) for(int i=a;i<b;i++)
#define FOR(i,a,b) for(int i=a;i<b;i++)
#define FORe(i,a,b) for(int i=a;i<=b;i++)
#define FORr(i,a,b) for(int i=a;i>b;i--)
#define FORre(i,a,b) for(int i=a;i>=b;i--)
#define pb push_back
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
const ll inf = 1e9+7;
t64 ceil_div(t64 a,t64 b){
t64 ans = a/b;
if(a%b != 0)ans++;
return ans;
}
void solve(){
int n,m; cin >> n >> m;
vector<t64>a(n);
vector<t64>pref(n);
vector<pair<t64,int> > maxes;
rep(i,0,n){
cin >> a[i];
}
pref[0] = a[0];
maxes.pb(pair<t64,int>(a[0],0));
rep(i,1,n){
pref[i] = pref[i-1]+a[i];
if(pref[i] > maxes.back().first){
maxes.pb(pair<t64,int>(pref[i],i));
}
}
t64 x;
rep(i,0,m){
cin >> x;
t64 ans = 0;
if(x <= maxes.back().first){
// cout << "C1\n";
ans = lower_bound(maxes.begin(),maxes.end(),pair<t64,int>(x,0))->second + 1;
}
else{
if(pref[n-1] <= 0){
// cout << "C2\n";
ans = 0;}
else{
t64 aux = x - maxes.back().first;
t64 num = ceil_div(aux,pref[n-1]);
x -= (num * pref[n-1]);
ans = num * n;
ans += lower_bound(maxes.begin(),maxes.end(),pair<t64,int>(x,0))->second + 1;
}
}
cout << ans -1 << " ";
}
cout << endl;
}
void solve2(){
int n,m; cin >> n >> m;
t64 total_sum = 0;
t64 highest_sum = 0;
int highest_sum_moves = 0;
map<t64,int> sums;
vector<t64> a(n);
rep(i,0,n){
cin >> a[i];
total_sum += a[i];
if(sums[total_sum] == 0){
sums[total_sum] = i;
}
highest_sum = max(highest_sum,total_sum);
if(total_sum > highest_sum){
highest_sum = total_sum;
highest_sum_moves = i;
}
}
vector<t64> x(m); rep(i,0,m) cin >> x[i];
// cout << imie(total_sum) << endl;
if(total_sum <= 0){
for(auto v: x){
if(v > highest_sum){
cout << -1 << " ";
}
else{
int ans = inf;
map<t64,int>::iterator it;
for(it = sums.end()--;it != sums.begin(); it--){
if(it->first >= v){
ans = min(ans, it->second);
}
else break;
}
if(it->first >= v){
ans = min(ans, it->second);
}
cout << ans << " ";
}
}
cout << endl;
}
else{
for(auto v: x){
int pre = 0;
if(v > highest_sum){
pre += n-1;
v -= highest_sum;
}
while(v > highest_sum){
pre += n;
v -= highest_sum;
}
// cout << imie(pre) << imie(v) << endl;
int ans = inf;
map<t64,int>::iterator it;
for(it = sums.end()--;it != sums.begin(); it--){
if(it->first >= v){
if(pre != 0){
ans = min(ans,1+pre + it->second);
}
else{
ans = min(ans,pre + it->second);
}
}
else break;
}
if(it->first >= v){
if(pre != 0){
ans = min(ans,1+pre + it->second);
}
else{
ans = min(ans,pre + it->second);
}
}
cout << ans << " ";
}
cout << endl;
}
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while(t--){
solve();
}
return 0;
}
| 13 |
CPP
|
#include <bits/stdc++.h>
#define w(x) int x; cin >> x; while(x--)
#define endl '\n'
#define mod 1000000007
#define ll long long
using namespace std;
ll pow(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
if(x == 0)
return 0;
while(y > 0) {
if(y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll _pow(ll a, ll b) {
if(!b)
return 1;
ll temp = _pow(a, b / 2);
temp = temp * temp;
if(b & 1)
return a * temp;
return temp;
}
ll invmod(ll a, ll m) {
return pow(a, m - 2, m);
}
ll cl(ll a, ll x) {
return a % x == 0 ? a / x : a / x + 1;
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
w(t) {
ll n, m, sum = 0;
cin >> n >> m;
vector<ll> v(n), q(m);
vector<pair<ll, ll>> pre;
for(int i = 0; i < n; i++) {
cin >> v[i];
sum += v[i];
if(sum > 0) {
if(pre.empty() || pre.back().first < sum)
pre.push_back({sum, i});
}
}
for(int i = 0; i < m; i++)
cin >> q[i];
for(int i = 0; i < m; i++) {
auto j = lower_bound(pre.begin(), pre.end(), make_pair(q[i], 0LL));
if(j != pre.end())
cout << j -> second << " ";
else if(sum <= 0)
cout << -1 << " ";
else {
q[i] -= pre.back().first;
ll val = cl(q[i], sum);
q[i] -= val * sum;
ll ans = val * n;
j = lower_bound(pre.begin(), pre.end(), make_pair(q[i] + pre.back().first, 0LL));
ans += j -> second;
cout << ans << " ";
}
}
cout << endl;
}
}
| 13 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<LL,LL> PLL;
const int INF = 0x3f3f3f3f, N = 2e5 + 10;
inline int lc(int u) {return u << 1;}
inline int rc(int u) {return u << 1 | 1;}
inline int lowbit(int x) {return x & (-x);}
LL a[N], s[N];
LL mm[N];
struct node {
LL val;
int idx;
bool operator < (const node &B) const {
if (val != B.val) return val < B.val;
return idx < B.idx;
}
} p[N];
inline void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i ++ ) mm[i] = -1e9 - 1;
LL ma = -1e9 - 1, mi = 1e9 + 1;
for (int i = 1; i <= n; i ++ ) {
int x;
scanf("%d", &x);
s[i] = s[i - 1] + (LL)x;
ma = max(ma, s[i]);
mi = min(mi, s[i]);
p[i] = {s[i], i};
mm[i] = max(mm[i - 1], s[i]);
}
LL T = s[n];
while (m -- ) {
int x;
scanf("%d", &x);
if (ma < x && T <= 0) printf("-1 ");
else {
if (ma < x) {
LL round = (x - ma + T - 1) / T;
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (round * T + mm[mid] >= x) r = mid;
else l = mid + 1;
}
printf("%lld ", round * n + l - 1);
} else {
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (mm[mid] >= x) r = mid;
else l = mid + 1;
}
printf("%d ", l - 1);
}
}
}
puts("");
}
int main() {
// ios::sync_with_stdio(false), cin.tie(nullptr);
int t;
scanf("%d", &t);
while (t -- )
solve();
return 0;
}
| 13 |
CPP
|
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#include <bits/stdc++.h>
using namespace std ;
const int inf = 1e9 ;
const int MAX = 2e5 + 10 ;
long long arr[MAX] ;
int val[MAX] , suff[MAX] ;
int n , q ;
vector<long long>v ;
long long sum = 0 ;
void compress()
{
for(int i = 1 ; i <= n ; ++i)
v.push_back(arr[i]) ;
sort(v.begin() , v.end()) ;
v.erase(unique(v.begin() , v.end()) , v.end()) ;
for(int i = 1 ; i <= n ; ++i)
arr[i] = lower_bound(v.begin() , v.end() , arr[i]) - v.begin() + 1 ;
}
void preprocess()
{
for(int i = 1 ; i <= n ; ++i)
arr[i] += arr[i-1] ;
sum = arr[n] ;
compress() ;
for(int i = 1 ; i <= n ; ++i)
val[i] = inf ;
for(int i = 1 ; i <= n ; ++i)
val[arr[i]] = min(val[arr[i]] , i) ;
suff[n] = val[n] ;
for(int i = n-1 ; i >= 1 ; --i)
suff[i] = min(suff[i+1] , val[i]) ;
}
int check(long long a , long long x)
{
long long y = a * sum ;
if(y >= x)
return 0 ;
x -= y ;
if(x > v.back())
return inf ;
int idx = lower_bound(v.begin() , v.end() , x) - v.begin() ;
return suff[idx+1] ;
}
int main()
{
ios_base::sync_with_stdio(0) ;
cin.tie(0) ;
int t ;
cin>>t ;
while(t--)
{
v.clear() ;
cin>>n>>q ;
for(int i = 1 ; i <= n ; ++i)
cin>>arr[i] ;
preprocess() ;
while(q--)
{
int x ;
cin>>x ;
int ans = check(0 , x) ;
if(ans != inf)
cout<<ans-1<<" " ;
else if(sum <= 0)
cout<<-1<<" " ;
else
{
long long l = 1 , r = (x+sum-1) / sum ;
long long ans = r*n ;
while(l <= r)
{
long long mid = (l + r) >> 1ll ;
if(check(mid , x) != inf)
ans = mid , r = mid-1 ;
else
l = mid+1 ;
}
ans = ans * n + check(ans , x) ;
cout<<ans-1<<" " ;
}
}
cout<<"\n" ;
}
return 0 ;
}
| 13 |
CPP
|
#include <bits/stdc++.h>
#define IO ios_base::sync_with_stdio(false);\
cin.tie(0);\
cout.tie(0)
using namespace std;
typedef long long ll;
const int N = 2e5 + 10;
int t;
int n, m;
ll a[N], b[N];
ll c[N];
int main()
{
IO;
cin >> t;
while(t --)
{
cin >> n >> m;
for(int i = 1; i <= n; i ++)
{
cin >> a[i];
a[i] += a[i - 1];
c[i] = max(c[i - 1], a[i]);
}
for(int i = 1; i <= m; i ++)
{
cin >> b[i];
if(c[n] >= b[i])
cout<<lower_bound(c + 1, c + n + 1, b[i]) - c - 1<<" ";
else
{
if(a[n] <= 0)
cout<<"-1"<<" ";
else
{
ll sum = (b[i] - c[n] + a[n] - 1) / a[n];
b[i] -= sum * a[n];
sum *= n;
sum += lower_bound(c + 1, c + n + 1, b[i]) - c - 1;
cout<<sum<<" ";
}
}
}
cout<<'\n';
}
return 0;
}
| 13 |
CPP
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=3e5+10;
ll sum[maxn];
ll arr[maxn],xrr[maxn];
ll ans[maxn];
#define PII pair<ll,int>
int main()
{
int T;cin>>T;
while(T--)
{
int n,m;cin>>n>>m;
ll mx=-(1e12);
for(int i=1;i<=n;i++) cin>>arr[i];
for(int i=1;i<=m;i++) cin>>xrr[i];
for(int i=1;i<=n;i++) sum[i]=sum[i-1]+arr[i];
vector<PII> v;v.clear();
for(int i=1;i<=n;i++) if(sum[i]>mx) v.push_back({sum[i],i}),mx=sum[i];
// sort(v.begin(),v.end(),[](PII a,PII b){if(a.first!=b.first) return a.first<b.first;
// else return a.second<b.second;});
vector<ll> lowv;lowv.clear();
for(auto x:v) lowv.push_back(x.first);
for(int i=1;i<=m;i++)
{
ll cur=xrr[i];
int pos=lower_bound(lowv.begin(),lowv.end(),cur)-lowv.begin();
if(pos!=lowv.size())
{
if(lowv[pos]>=cur) ans[i]=v[pos].second-1;
}
else
{
if(sum[n]<=0 ) ans[i]=-1;
else
{
// ll lst=cur-mx;
// ll k=0;
// if(lst%sum[n]==0) k=lst/sum[n];
// else k=lst/sum[n]+1;
ll k=(cur-mx-1)/sum[n]+1;
ll tmp_lst=k*sum[n];
pos=lower_bound(lowv.begin(),lowv.end(),cur-tmp_lst)-lowv.begin();
if(pos!=lowv.size()) ans[i]=v[pos].second-1+k*n;
else ans[i]=-1;
}
}
}
for(int i=1;i<=m;i++) cout<<ans[i]<<" ";
cout<<endl;
}
return 0;
}
| 13 |
CPP
|
from __future__ import division, print_function
from itertools import permutations
import threading,bisect,math,heapq,sys
from collections import deque
# threading.stack_size(2**27)
# sys.setrecursionlimit(10**4)
from sys import stdin, stdout
i_m=9223372036854775807
def cin():
return map(int,sin().split())
def ain(): #takes array as input
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
prime=[]
def dfs(n,d,v):
v[n]=1
x=d[n]
for i in x:
if i not in v:
dfs(i,d,v)
return p
def block(x):
v = []
while (x > 0):
v.append(int(x % 2))
x = int(x / 2)
ans=[]
for i in range(0, len(v)):
if (v[i] == 1):
ans.append(2**i)
return ans
"""**************************MAIN*****************************"""
def main():
t=inin()
for _ in range(t):
n,m=cin()
a=ain()
f=sum(a)
b=ain()
s=[]
p=0
ans=[]
for i in range(n):
p+=a[i]
q=p
if len(s)>0:
q=s[-1]
s.append(max(q,p))
for x in b:
if s[-1]<x and f<=0:
ans.append(-1)
continue
an=0
if x>s[-1]:
p=(x-s[-1])/f
p=math.ceil(p)
x=x-p*f
an=n*p
if x>0:
q=bisect.bisect_left(s,x)
ans.append(an+q)
print(*ans)
"""***********************************************"""
def intersection(l,r,ll,rr):
# print(l,r,ll,rr)
if (ll > r or rr < l):
return 0
else:
l = max(l, ll)
r = min(r, rr)
return max(0,r-l+1)
######## Python 2 and 3 footer by Pajenegod and c1729
fac=[]
def fact(n,mod):
global fac
fac.append(1)
for i in range(1,n+1):
fac.append((fac[i-1]*i)%mod)
f=fac[:]
return f
def nCr(n,r,mod):
global fac
x=fac[n]
y=fac[n-r]
z=fac[r]
x=moddiv(x,y,mod)
return moddiv(x,z,mod)
def moddiv(m,n,p):
x=pow(n,p-2,p)
return (m*x)%p
def GCD(x, y):
x=abs(x)
y=abs(y)
if(min(x,y)==0):
return max(x,y)
while(y):
x, y = y, x % y
return x
def Divisors(n) :
l = []
ll=[]
for i in range(1, int(math.sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
l.append(i)
else :
l.append(i)
ll.append(n//i)
l.extend(ll[::-1])
return l
def SieveOfEratosthenes(n):
global prime
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
f=[]
for p in range(2, n):
if prime[p]:
f.append(p)
return f
def primeFactors(n):
a=[]
while n % 2 == 0:
a.append(2)
n = n // 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
a.append(i)
n = n // i
if n > 2:
a.append(n)
return a
"""*******************************************************"""
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s:self.buffer.write(s.encode('ascii'))
self.read = lambda:self.buffer.read().decode('ascii')
self.readline = lambda:self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# Cout implemented in Python
class ostream:
def __lshift__(self,a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = '\n'
# Read all remaining integers in stdin, type is given by optional argument, this is fast
def readnumbers(zero = 0):
conv = ord if py2 else lambda x:x
A = []; numb = zero; sign = 1; i = 0; s = sys.stdin.buffer.read()
try:
while True:
if s[i] >= b'R' [0]:
numb = 10 * numb + conv(s[i]) - 48
elif s[i] == b'-' [0]: sign = -1
elif s[i] != b'\r' [0]:
A.append(sign*numb)
numb = zero; sign = 1
i += 1
except:pass
if s and s[-1] >= b'R' [0]:
A.append(sign*numb)
return A
# threading.Thread(target=main).start()
if __name__== "__main__":
main()
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
#define N 200020
int a[N], x[N], y[N];
long long int s[N];
bool cmp(int i, int j) {
return s[i] < s[j];
}
int main() {
int tc;
scanf("%d", &tc);
for(int cc=0; cc<tc; cc++) {
int n, m;
scanf("%d %d", &n, &m);
for(int i=0; i<n; i++) {
scanf("%d", &a[i]);
x[i] = i;
}
s[0] = a[0];
for(int i=1; i<n; i++) {
s[i] = s[i-1] + a[i];
}
sort(x, x+n, cmp);
y[n-1] = x[n-1];
for(int i=n-2; i>=0; i--) {
y[i] = min(y[i+1], x[i]);
}
for(int i=0; i<m; i++) {
int sum;
scanf("%d", &sum);
if(s[n-1] <= 0 && s[x[n-1]] < sum) {
printf("-1 ");
continue;
}
long long int step = 0;
if(s[n-1] > 0) {
int start = 0, end = ((long long int)sum + sum) / s[n-1], p = -1;
while(start <= end) {
int mid = (start + end) / 2;
if((long long int)mid * s[n-1] + s[x[n-1]] >= sum) {
p = mid;
end = mid - 1;
} else {
start = mid + 1;
}
}
// assert(p != -1);
if(p != -1) {
sum = sum - (p * s[n-1]);
step = step + (long long int)p * n;
}
}
int start = 0, end = n-1, p = -1;
while(start <= end) {
int mid = (start + end) / 2;
if(sum <= s[x[mid]]) {
p = mid;
end = mid - 1;
} else {
start = mid + 1;
}
}
// printf("step before: %d ", step);
assert(p != -1);
step += y[p];
printf("%lld ", step);
}
printf("\n");
}
return 0;
}
| 13 |
CPP
|
import sys
import math
import heapq
import bisect
from collections import Counter
from collections import defaultdict
from io import BytesIO, IOBase
import string
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
self.BUFSIZE = 8192
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def get_int():
return int(input())
def get_ints():
return list(map(int, input().split(' ')))
def get_int_grid(n):
return [get_ints() for _ in range(n)]
def get_str():
return input().split(' ')
def yes_no(b):
if b:
return "YES"
else:
return "NO"
def binary_search(good, left, right, delta=1, right_true=False):
"""
Performs binary search
----------
Parameters
----------
:param good: Function used to perform the binary search
:param left: Starting value of left limit
:param right: Starting value of the right limit
:param delta: Margin of error, defaults value of 1 for integer binary search
:param right_true: Boolean, for whether the right limit is the true invariant
:return: Returns the most extremal value interval [left, right] which is good function evaluates to True,
alternatively returns False if no such value found
"""
limits = [left, right]
while limits[1] - limits[0] > delta:
if delta == 1:
mid = sum(limits) // 2
else:
mid = sum(limits) / 2
if good(mid):
limits[int(right_true)] = mid
else:
limits[int(~right_true)] = mid
if good(limits[int(right_true)]):
return limits[int(right_true)]
else:
return False
def prefix_sums(a):
p = [0]
for x in a:
p.append(p[-1] + x)
return p
def prefix_max(a):
p = [-float('inf')]
for x in a:
p.append(max(p[-1], x))
return p
def ceil_div(a, b):
return a // b + int(a % b != 0)
def solve_a():
n = get_int()
a = get_ints()
k = 0
for i in range(n - 1):
A = max(a[i], a[i + 1])
B = min(a[i], a[i + 1])
while 2 * B < A:
k += 1
B *= 2
return k
def solve_b():
n = get_int()
a = get_ints()
rems = [x % 3 for x in a]
count_rems = [rems.count(i) for i in range(3)]
k = 0
for repeat in range(2):
for i in range(3):
if count_rems[i] > n // 3:
k += count_rems[i] - n // 3
count_rems[(i + 1) % 3] += count_rems[i] - n // 3
count_rems[i] = n // 3
return k
def solve_c():
cubes = set()
i = 1
while i ** 3 < 10 ** 12 + 1:
cubes.add(i ** 3)
i += 1
def solve():
x = get_int()
j = 1
while j ** 3 <= x:
if x - j ** 3 in cubes:
return "YES"
j += 1
return "NO"
t = get_int()
for _ in range(t):
print(solve())
def solve_d():
n = get_int()
p = get_ints()
dp = [-1] * n
for i in range(n, 0, -1):
X = p.index(i)
m = -1
for j in range(X, n):
if dp[j] > - 1:
m = max(m, dp[j])
break
for j in range(X, -1, -1):
if dp[j] > - 1:
m = max(m, dp[j])
break
dp[X] = m + 1
res = {}
return dp
def solve_e():
n = get_int()
a = get_ints()
a_uniq = list(set(a))
a_uniq.sort()
a_count = Counter(a)
def good(k):
x = a_uniq[k]
#Can the number of tokens at kth position win
for i in range(len(a_uniq)):
if x >= a_uniq[i]:
x += a_uniq[i] * (a_count[a_uniq[i]] - int(i == k))
else:
return False
return True
L = -1
R = len(a_uniq) - 1
bs = binary_search(good, L, R, right_true=True)
u = a_uniq[bs]
res = []
for i in range(n):
if a[i] >= u:
res.append(i + 1)
return res
def solve_f():
n = get_int()
a = get_ints()
C = Counter(a)
candidates = set(C.values())
S = float('inf')
for cand in candidates:
tmp = 0
for k in C:
if C[k] < cand:
tmp += C[k]
elif C[k] > cand:
tmp += C[k] - cand
S = min(S, tmp)
return S
def solve_g():
n, m = get_ints()
a = get_ints()
x = get_ints()
S = sum(a)
p = prefix_sums(a)
pm = prefix_max(p)[2:]
def respond(y):
if S <= 0 and pm[-1] < y:
return - 1
if S > 0:
rots = max(0, ceil_div(y - pm[-1], S))
else:
rots = 0
y -= rots * S
if y == 0:
z = -1
else:
z = bisect.bisect_left(pm, y)
return rots * n + z
response = [respond(y) for y in x]
return response
t = get_int()
for _ in range(t):
print(*solve_g())
| 13 |
PYTHON3
|
from math import log2
def found(a, value,m):
mid = len(a) // 2
low = 0
high = len(a) - 1
while low < high:
if value <= a[mid][0]:
high = mid
else:
low = mid + 1
mid = (low + high) // 2
if a[mid][0] >= value:
return m[mid]
else:
return m[mid]
t = int(input())
for i in range(t):
n,m = map(int, input().split())
a = list(map(int, input().split()))
q = list(map(int, input().split()))
circle = sum(a)
s = [[0,0]]
for i in range(len(a)):
s.append([a[i] + s[-1][0], i+1])
max_circle = max(s)[0]
s.sort()
mini = s[-1][1]
mini_lol = [0 for i in range(len(s))]
for i in range(len(mini_lol)-1, -1,-1):
mini = min(mini, s[i][1])
mini_lol[i] = mini
answer = []
for x in q:
if (x > max_circle and circle <= 0):
ans = -1
elif x <= max_circle:
ans = found(s,x,mini_lol) -1
else:
delta = x - ((x - max_circle)//circle)*circle
ans = len(a)*((x - max_circle)//circle)
if delta > max_circle:
delta -= circle
ans += len(a)
x = delta
ans += found(s,x, mini_lol) -1
answer.append(ans)
print(*answer)
'''
1
3 10
1 -1 1
1 2 3 4 5 6 7 8 9 10
'''
| 13 |
PYTHON3
|
#include<bits/stdc++.h>
using namespace std;
#define Go_ ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define ll long long int
#define llu long long unsigned int
#define pii pair<int ,int>
#define PII pair<ll ,ll>
const int Max=1e9+100;
const ll MAX=1e18+500;
const ll sz=2e5+100;
map<ll,ll> mp;
int main()
{
Go_
ll a,b,c,i,j,k,q,p,x,y,ct,ct1,m,l,r,x1,y1,mn,h,sum1,in,z,mid,n,mx;
char ch;
double d;
string str1,str2,str;
bool bl,bl1;
int t,cs=1;
cin>>t;
while(t--)
{
cin>>n>>m;
mp.clear();
ll sum=0;
vector<ll> test;
for(ll i=1;i<=n;i++)
{
cin>>x;
sum+=x;
if(mp.count(sum)==0){
test.push_back(sum);
mp[sum]=i-1;
}
}
sort(test.begin(), test.end());
ll siz=test.size();
ll mn[siz];
if(siz>0) mn[siz-1]=mp[test[siz-1]];
for(ll i=siz-2;i>=0;i--){
mn[i]=min(mn[i+1], mp[test[i]]);
}
vector<ll> ans;
for(ll i=1;i<=m;i++)
{
cin>>x;
auto it=lower_bound(test.begin(), test.end(), x);
if(it != test.end()){
ll pos=it-test.begin();
pos=mn[pos];
ans.push_back(pos);
}
else{
if(sum<=0) ans.push_back(-1ll);
else{
ll p=(x/sum);
if(p<0ll) {
ans.push_back(-1ll);
continue;
}
p=((x-test[siz-1]))/sum+((x-test[siz-1])%sum>0ll);
ll le=(p * (n-1))+max(0ll, p-1);
ll rem=(x-(p*sum));
if(rem>0ll){
++le;
ll pos=lower_bound(test.begin(), test.end(), rem)-test.begin();
le+=mn[pos];
}
ans.push_back(le);
}
}
}
for(auto xx: ans) cout<<xx<<" ";
cout<<'\n';
}
}
| 13 |
CPP
|
from os import path
import sys,time
# mod = int(1e9 + 7)
# import re
from math import ceil, floor,gcd,log,log2 ,factorial,sqrt
from collections import defaultdict ,Counter , OrderedDict , deque
# from itertools import combinations
# from string import ascii_lowercase ,ascii_uppercase
# from bisect import *
from functools import reduce
from operator import mul
maxx = float('inf')
#----------------------------INPUT FUNCTIONS------------------------------------------#
I = lambda :int(sys.stdin.buffer.readline())
tup= lambda : map(int , sys.stdin.buffer.readline().split())
lint = lambda :[int(x) for x in sys.stdin.buffer.readline().split()]
S = lambda: sys.stdin.readline().strip('\n')
grid = lambda r :[lint() for i in range(r)]
stpr = lambda x : sys.stdout.write(f'{x}' + '\n')
star = lambda x: print(' '.join(map(str, x)))
localsys = 0
start_time = time.time()
if (path.exists('input.txt')):
sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
#left shift --- num*(2**k) --(k - shift)
# st =ascii_lowercase
def bi(x):
l , h = 0 , n-1
res = n
while l <= h :
m = (l+h) >> 1
if pref_m[m] >= x :
res = m
h = m-1
else:
l = m+1
return -1 if res == n else res
for _ in range(I()):
n , m= tup()
a = lint()
b = lint()
pre = [a[i] for i in range(n)]
pref_m = [a[i] for i in range(n)]
for i in range(1 , n ):
pre[i]+=pre[i-1]
pref_m[i] = max(pre[i], pref_m[i-1])
if pre[-1] <= 0 :
for x in b:
print(bi(x),end = ' ')
else:
ma = max(pre)
for x in b:
t = max(0 , ceil((x - ma)/pre[-1]))
print(t*n + bi(x - t*pre[-1]) ,end=' ' )
print()
if localsys:
print("\n\nTime Elased :",time.time() - start_time,"seconds")
| 13 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
///////////////////////////////////*****************//////////////////////////////////////
typedef long long ll;
ll z=1000000007;
ll fact[400005];
void buildfact()
{
fact[0]=1;
for(ll i=1;i<400005;i++)
{
fact[i]=(fact[i-1]*i)%z;
}
}
ll power(ll a,ll p)
{
if(p==0)
return 1;
if(p%2==0)
return power((a*a)%z,p/2);
return (a*power(a,p-1))%z;
}
ll ncr(ll n,ll r)
{
if(n<r)
return 0;
ll num=fact[n];
ll deno=(fact[r]*fact[n-r])%z;
deno=power(deno,z-2);
ll ans=(num*deno)%z;
return ans;
}
//////////////////////////////////////****************//////////////////////////////////////
void solve(int oper)
{
ll n,m;
cin>>n>>m;
ll sum=0;
ll arr[n],queries[m];
for(int i=0;i<n;i++)
{
cin>>arr[i];
sum+=arr[i];
if(i>0)
arr[i]+=arr[i-1];
}
for(int i=0;i<m;i++)
cin>>queries[i];
vector <ll> helper;
vector <ll> ans(m,0);
helper.push_back(arr[0]);
map <int,int> index;
index[0]=0;
for(int i=1;i<n;i++)
{
if(helper[helper.size()-1]<arr[i])
{
helper.push_back(arr[i]);
index[helper.size()-1]=i;
}
}
for(int i=0;i<m;i++)
{
ll x=queries[i];
ll sol=0;
ll lastval=helper[helper.size()-1];
if(x>lastval&&sum<=0)
ans[i]=-1;
else
{
if(x<=lastval)
{
int in=lower_bound(helper.begin(),helper.end(),x)-helper.begin();
ans[i]=index[in];
}
else{
ll times=ceil(float(x-lastval)/sum);
x-=(times*sum);
int in=lower_bound(helper.begin(),helper.end(),x)-helper.begin();
ans[i]=index[in]+times*n;
}
}
}
for(int i=0;i<m;i++)
cout<<ans[i]<<" ";
cout<<endl;
return;
}
int main()
{
ll t;
t=1;
cin>>t;
//buildfact();
int i=1;
while(i<=t)
{
solve(i);
i++;
}
return 0;
}
| 13 |
CPP
|
import collections
import string
import math
import copy
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip("\r\n")
# n = 0
# m = 0
# n = int(input())
# li = [int(i) for i in input().split()]
# s = sorted(li)
mo = 998244353
def exgcd(a, b):
if not b:
return 1, 0
y, x = exgcd(b, a % b)
y -= a//b * x
return x, y
def getinv(a, m):
x, y = exgcd(a, m)
return -(-1) if x == 1 else x % m
def comb(n, b):
res = 1
b = min(b, n-b)
for i in range(b):
res = res*(n-i)*getinv(i+1, mo) % mo
# res %= mo
return res % mo
def quickpower(a, n):
res = 1
while n:
if n & 1:
res = res * a % mo
n >>= 1
a = a*a % mo
return res
def dis(a, b):
return abs(a[0]-b[0]) + abs(a[1]-b[1])
def getpref(x):
if x > 1:
return (x)*(x-1) >> 1
else:
return 0
def orafli(upp):
primes = []
marked = [False for i in range(upp+3)]
for i in range(2, upp):
if not marked[i]:
primes.append(i)
for j in primes:
if i*j >= upp:
break
marked[i*j] = True
if i % j == 0:
break
return primes
# history = {}
# askctr = 0
# def ask(s):
# global askctr, history
# if s in history:
# return history[s]
# askctr+=1
# print(f"? {s}", flush=True)
# ret = int(input())
# hisadd(s, ret)
# chkans(s)
# return ret
# def answer(s):
# print(f"! {s}", flush=True)
# # return int(input())
# def getans(history, l, r):
# for i in range(l, r+1):
# ask(i)
# history[i] = int(input())
# if i==2:
# if 1 in history:
# if history[2]>history[1]:
# answer(1)
# return
# else:
# if i-1 in history and i-2 in history:
# if history[i-1]<history[i-2] and history[i-1]<history[i]:
# answer(i-1)
# return
# def chkans(i):
# global history, n
# if i==1:
# if history.get(2,0)>history.get(1,999999999):
# answer(1)
# exit(0)
# return True
# elif i==n:
# if history.get(n-1,0)>history.get(n,999999999):
# answer(n)
# exit(0)
# return True
# elif history.get(i-1, 0) > history.get(i, 99999999) < history.get(i+1, 0):
# if 0<i<=n:
# answer(i)
# exit(0)
# return True
# return False
# def hisadd(pos, val):
# global history
# if val == 1:
# answer(pos)
# exit(0)
# return True
# else:
# history[pos] = val
# return chkans(pos)
def solve():
n,m = map(int, input().split())
a = [int(i) for p,i in enumerate(input().split())]
mx = -1145141919810931
su = 0
ans = [0 for i in range(m)]
for i in a:
su+=i
mx = max(mx,su)
# mx = max(a)
s = sum(a)
x = [[int(i), p] for p,i in enumerate(input().split())]
if s>0:
for p,pp in enumerate(x):
i,j=pp
if i>mx:
lop = math.ceil((i - mx)/s)
ans[j]+=lop*n
x[p][0] -= math.ceil((i - mx)/s)*s
x.sort(reverse=True)
su = 0
sec = 0
# his = {}
for i in a:
su += i
if not x:
break
else:
while x:
if x[-1][0]<=su:
ans[x[-1][1]] += sec
x.pop()
else:
break
# his[su] = sec
sec+=1
if s<=0:
while x:
t, pos = x.pop()
ans[pos] = -1
print(*ans)
# else:
# for i in range(len(x)):
# subb = math.ceil((x[i][0] - mx)/k)
# x[i][0] -=
# while x:
# t, pos = x.pop()
t = int(input())
for ti in range(t):
solve()
| 13 |
PYTHON3
|
#!/usr/bin/env python3
# set vim: fdm=marker sw=4 ts=4 et
import bisect
# {{{ IntervalTree
class IntervalTree:
@staticmethod
def get_depth(n):
depth = 0
i = 1
while i < n:
depth += 1
i <<= 1
return depth
def __init__(self, n):
self.n = n
self.depth = IntervalTree.get_depth(n)
self.top = 1 << self.depth
self.v = []
for i in range(self.top + self.n):
self.v.append(None) # max value
def add(self, pos, value):
assert pos < self.n
idx = 1
mask = 1 << (self.depth - 1)
while idx < len(self.v):
if self.v[idx] is None or self.v[idx] < value:
self.v[idx] = value
idx <<= 1
if (pos & mask) != 0:
idx += 1
mask >>= 1
def get_impl(self, idx, l, r, v):
if r - l == 1:
return l
idx <<= 1
m = (l + r) // 2
if self.v[idx] >= v:
return self.get_impl(idx, l, m, v)
else:
return self.get_impl(idx + 1, m, r, v)
def get(self, v):
if self.v[1] < v:
return self.n
return self.get_impl(1, 0, self.top, v)
# }}}
for _ in range(int(input())):
n, m = map(int, input().split())
a = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
b = []
if n == 1:
for x_i in x:
if a[0] <= 0:
b.append(-1)
else:
b.append((x_i + a[0] - 1) // a[0] - 1)
else:
sum_a = sum(a)
s = 0
it = IntervalTree(n)
for i in range(n):
s += a[i]
it.add(i, s)
max_s_i = it.v[1]
for x_i in x:
pos = it.get(x_i)
if pos < n:
b.append(pos)
continue
if sum_a <= 0:
b.append(-1)
continue
b_i = (x_i - max_s_i) // sum_a
x_i -= sum_a * b_i
b_i *= n
while True:
pos = it.get(x_i)
if pos == n:
b_i += n
x_i -= sum_a
else:
b_i += pos
break
b.append(b_i)
print(" ".join([str(i) for i in b]))
| 13 |
PYTHON3
|
from bisect import bisect_left
import math
ii = lambda : int(input())
li = lambda:list(map(int,input().split()))
t = int(input())
for _ in range(t):
n,m = li()
a = li()
xl = li()
mx = []
curSum = 0
mxind = []
res = []
for i in range(n):
curSum+=a[i]
if mx==[] or mx[-1]<curSum:
mx.append(curSum)
mxind.append(i)
for x in xl:
if (x>mx[-1] and curSum<=0):
res.append(-1)
else:
temp = 0
if (x>mx[-1]):
dif = x-mx[-1]
temp = math.ceil(dif/curSum)
res.append(temp*n+mxind[bisect_left(mx,x-temp*curSum)])
print(*res)
| 13 |
PYTHON3
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.