提出 #15348416 - 2013年日本情報オリンピック春合宿 2日目

コンテスト時間: 2013-03-21 09:30:00+0900 ~ 2013-03-21 14:30:00+0900 (300分) AtCoderホームへ戻る

提出 #15348416

ソースコード拡げる

#line 2 "/Users/kaage/Desktop/ProgrammingWorkspace/library/other/template.hpp"
#define _CRT_SECURE_NO_WARNINGS
#pragma target("avx")
#pragma optimize("O3")
#pragma optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i,n) for(int i=0;i<(lint)(n);i++)
#define REP(i,n) for(int i=1;i<=(lint)(n);i++)
#define all(V) V.begin(),V.end()
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
typedef std::pair<lint, lint> LP;
constexpr int INF = INT_MAX/2;
constexpr lint LINF = LLONG_MAX/2;
constexpr double eps = DBL_EPSILON;
constexpr double PI=3.141592653589793238462643383279;
template<class T>
class prique :public std::priority_queue<T, std::vector<T>, std::greater<T>> {};
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
	if (lhs < rhs) {
		lhs = rhs;
		return 1;
	}
	return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
	if (lhs > rhs) {
		lhs = rhs;
		return 1;
	}
	return 0;
}
inline lint gcd(lint a, lint b) {
	while (b) {
		lint c = a;
		a = b; b = c % b;
	}
	return a;
}
inline lint lcm(lint a, lint b) {
	return a / gcd(a, b) * b;
}
bool isprime(lint n) {
	if (n == 1)return false;
	for (int i = 2; i * i <= n; i++) {
		if (n % i == 0)return false;
	}
	return true;
}
template<typename T>
T mypow(T a, unsigned int b) {
	if (!b)return T(1);
	if (b & 1)return mypow(a, b - 1) * a;
	T memo = mypow(a, b >> 1);
	return memo * memo;
}
lint modpow(lint a, lint b, lint m) {
	if (!b)return 1;
	if (b & 1)return modpow(a, b - 1, m) * a % m;
	lint memo = modpow(a, b >> 1, m);
	return memo * memo % m;
}
template<typename T>
void printArray(std::vector<T>& vec) {
	rep(i, vec.size() - 1)std::cout << vec[i] << " ";
	std::cout << vec.back() << std::endl;
}
template<typename T>
void printArray(T l, T r) {
	T rprev = r;
	rprev--;
	for (T i = l; i != rprev; i++) {
		std::cout << *i << " ";
	}
	std::cout << *rprev << std::endl;
}
#line 3 "/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/SegTree.hpp"
template<typename T>
class SegTree {
protected:
	unsigned int n = 1, rank = 0;
	std::vector<T> node;
	T nodee;
	virtual T nodef(const T&, const T&)const = 0;
public:
	SegTree(unsigned int m, T init, T nodee):nodee(nodee) {
		while (n < m) {
			n *= 2;
			rank++;
		}
		node.resize(2 * n);
		for (unsigned int i = n; i < 2 * n; i++)node[i] = init;
	}
	SegTree(const std::vector<T>& initvec, T nodee):nodee(nodee) {
		unsigned int m = initvec.size();
		while (n < m) {
			n *= 2;
			rank++;
		}
		node.resize(2 * n);
		for (unsigned int i = n; i < 2 * n; i++) {
			if (i - n < m)node[i] = initvec[i - n];
		}
	}
	virtual void update(int i, T x) {
		i += n;
		node[i] = x;
		while (i != 1) {
			i >>= 1;
			node[i] = nodef(node[2 * i], node[2 * i + 1]);
		}
	}
	virtual T query(int l, int r) {
		l += n; r += n;
		T ls = nodee, rs = nodee;
		while (l < r) {
			if (l & 1) {
				ls = nodef(ls, node[l]);
				l++;
			}
			if (r & 1) {
				r--;
				rs = nodef(node[r], rs);
			}
			l >>= 1; r >>= 1;
		}
		return nodef(ls, rs);
	}
	virtual T operator[](const int& x) {
		return node[n + x];
	}
	void print() {
		rep(i, n)std::cout << operator[](i) << " ";
		std::cout << std::endl;
	}
};
class RSQ :public SegTree<lint> {
	lint nodef(const lint& lhs,const lint& rhs)const{return lhs+rhs;}
public:
	RSQ(int size, const lint& def = 0) :SegTree<lint>(size, def, 0) {}
	RSQ(const std::vector<lint>& initvec) :SegTree<lint>(initvec, 0) {}
};
class RMiQ :public SegTree<lint> {
	lint nodef(const lint& lhs,const lint& rhs)const{return std::min(lhs,rhs);}
public:
	RMiQ(int size, const lint& def = 0) :SegTree<lint>(size, def, LINF) {}
	RMiQ(const std::vector<lint>& initvec) :SegTree<lint>(initvec, LINF) {}
};
class RMaQ :public SegTree<lint> {
	lint nodef(const lint& lhs,const lint& rhs)const{return std::max(lhs,rhs);}
public:
	RMaQ(int size, const lint& def = 0) :SegTree<lint>(size, def, -LINF) {}
	RMaQ(const std::vector<lint>& initvec) :SegTree<lint>(initvec, -LINF) {}
};
#line 4 "/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/IntervalSegTree.hpp"
template<typename T, typename U>
class IntervalSegTree :public SegTree<T> {
protected:
	using SegTree<T>::n;
	using SegTree<T>::rank;
	using SegTree<T>::node;
	using SegTree<T>::nodef;
	using SegTree<T>::nodee;
	std::vector<U> lazy;
	std::vector<bool> lazyflag;
	std::vector<int> width;
	virtual void lazyf(U&, const U&) = 0;
	virtual void updf(T&, const U&, const unsigned int&) = 0;
	void eval(int k) {
		for (int i = rank; i > 0; i--) {
			int nk = k >> i;
			if (lazyflag[nk]) {
				updf(node[2 * nk], lazy[nk], width[2 * nk]);
				updf(node[2 * nk + 1], lazy[nk], width[2 * nk + 1]);
				if (lazyflag[2 * nk])lazyf(lazy[2 * nk], lazy[nk]);
				else lazy[2 * nk] = lazy[nk];
				if (lazyflag[2 * nk + 1])lazyf(lazy[2 * nk + 1], lazy[nk]);
				else lazy[2 * nk + 1] = lazy[nk];
				lazyflag[2 * nk] = lazyflag[2 * nk + 1] = true;
				lazyflag[nk] = false;
			}
		}
	}
public:
	IntervalSegTree(unsigned int m, T init, T nodee) :SegTree<T>(m, init, nodee) {
		lazy.resize(2 * n); lazyflag.resize(2 * n); width.resize(2 * n);
		width[1] = n;
		for (unsigned int i = 2; i < 2 * n; i++) {
			width[i] = width[i >> 1] >> 1;
		}
	}
	IntervalSegTree(T nodee, const std::vector<T>& initvec) :SegTree<T>(initvec, nodee) {
		lazy.resize(2 * n); lazyflag.resize(2 * n); width.resize(2 * n);
		width[1] = n;
		for (unsigned int i = 2; i < 2 * n; i++) {
			width[i] = width[i >> 1] >> 1;
		}
	}
	void update(int i, U x) {
		i += n;
		eval(i);
		updf(node[i], x, width[i]);
		if (lazyflag[i])lazyf(lazy[i], x);
		else {
			lazyflag[i] = true;
			lazy[i] = x;
		}
		while (i /= 2)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
	void update(int l, int r, U x) {
		l += n; r += n;
		int nl = l, nr = r;
		while (!(nl & 1))nl >>= 1;
		while (!(nr & 1))nr >>= 1;
		nr--;
		eval(nl); eval(nr);
		while (l < r) {
			if (l & 1) {
				updf(node[l], x, width[l]);
				if (lazyflag[l])lazyf(lazy[l], x);
				else {
					lazyflag[l] = true;
					lazy[l] = x;
				}
				l++;
			}
			if (r & 1) {
				r--;
				updf(node[r], x, width[r]);
				if (lazyflag[r])lazyf(lazy[r], x);
				else {
					lazyflag[r] = true;
					lazy[r] = x;
				}
			}
			l >>= 1; r >>= 1;
		}
		while (nl >>= 1)node[nl] = nodef(node[2 * nl], node[2 * nl + 1]);
		while (nr >>= 1)node[nr] = nodef(node[2 * nr], node[2 * nr + 1]);
	}
	T query(int l, int r) {
		l += n; r += n;
		eval(l); eval(r - 1);
		int ls = nodee, rs = nodee;
		while (l < r) {
			if (l & 1) {
				ls = nodef(ls, node[l]);
				l++;
			}
			if (r & 1) {
				r--;
				rs = nodef(node[r], rs);
			}
			l >>= 1; r >>= 1;
		}
		return nodef(ls, rs);
	}
	T operator[](const int& x) {
		eval(n + x);
		return node[n + x];
	}
	T queryForAll() {
		return node[1];
	}
};
class RAQRSQ :public IntervalSegTree<lint, lint> {
	lint nodef(const lint& a, const lint& b)const { return a + b; }
	void lazyf(lint& a, const lint& b) { a += b; }
	void updf(lint& a, const lint& b, const unsigned int& width) { a += width * b; }
public:
	RAQRSQ(int size, const lint& def = 0) :IntervalSegTree<lint, lint>(size, def, 0) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
	RAQRSQ(const std::vector<lint>& initvec) :IntervalSegTree<lint, lint>((lint)0, initvec) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
};
class RAQRMiQ :public IntervalSegTree<lint, lint> {
	lint nodef(const lint& a, const lint& b)const { return std::min(a, b); }
	void lazyf(lint& a, const lint& b) { a += b; }
	void updf(lint& a, const lint& b, const unsigned int& width) { a += b; }
public:
	RAQRMiQ(int size, const lint& def = 0) :IntervalSegTree<lint, lint>(size, def, LINF) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
	RAQRMiQ(const std::vector<lint>& initvec) :IntervalSegTree<lint, lint>(LINF, initvec) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
};
class RAQRMaQ :public IntervalSegTree<lint, lint> {
	lint nodef(const lint& a, const lint& b)const { return std::max(a, b); }
	void lazyf(lint& a, const lint& b) { a += b; }
	void updf(lint& a, const lint& b, const unsigned int& width) { a += b; }
public:
	RAQRMaQ(unsigned int size, const lint& def = 0) :IntervalSegTree<lint, lint>(size, def, -LINF) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
	RAQRMaQ(const std::vector<lint>& initvec) :IntervalSegTree<lint, lint>(-LINF, initvec) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
};
class RUQRSQ :public IntervalSegTree<lint, lint> {
	lint nodef(const lint& a, const lint& b)const { return a + b; }
	void lazyf(lint& a, const lint& b) { a = b; }
	void updf(lint& a, const lint& b, const unsigned int& width) { a = width * b; }
public:
	RUQRSQ(int size, const int& def = 0) :IntervalSegTree<lint, lint>(size, def, 0) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
	RUQRSQ(const std::vector<lint>& initvec) :IntervalSegTree<lint, lint>((lint)0, initvec) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
};
class RUQRMiQ :public IntervalSegTree<lint, lint> {
	lint nodef(const int& a, const int& b)const { return std::min(a, b); }
	void lazyf(int& a, const int& b) { a = b; }
	void updf(int& a, const int& b, const unsigned int& width) { a = b; }
public:
	RUQRMiQ(int size, const lint& def = 0) :IntervalSegTree<lint, lint>(size, def, LINF) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
	RUQRMiQ(const std::vector<lint>& initvec) :IntervalSegTree<lint, lint>(LINF, initvec) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
};
class RUQRMaQ :public IntervalSegTree<lint, lint> {
	lint nodef(const lint& a, const lint& b)const { return std::max(a, b); }
	void lazyf(lint& a, const lint& b) { a = b; }
	void updf(lint& a, const lint& b, const unsigned int& width) { a = b; }
public:
	RUQRMaQ(int size, const lint& def = 0) :IntervalSegTree<lint, lint>(size, def, -LINF) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
	RUQRMaQ(const std::vector<lint>& initvec) :IntervalSegTree<lint, lint>(-LINF, initvec) {
		for (int i = n - 1; i > 0; i--)node[i] = nodef(node[2 * i], node[2 * i + 1]);
	}
};
#line 3 "/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/LiChaoTree.hpp"
class LiChaoTree{
    int n=1;
    std::vector<std::tuple<lint,lint,lint>> interval;
    std::vector<LP> node;
    std::vector<lint> cord;
    lint calc(LP l,lint x){
        return l.first*x+l.second;
    }
public:
    LiChaoTree(std::vector<lint> vec){
        vec.emplace_back(vec.back()+1);
        while(n<vec.size())n*=2;
        while(vec.size()<n+1)vec.emplace_back(vec.back()+1);
        node.assign(2*n,{0,LINF});
        interval.emplace_back(0,0,0);
        for(int range=n;range;range>>=1){
            for(int i=0;i<n;i+=range){
                if(range==1)interval.emplace_back(vec[i],0,vec[i+range]);
                else interval.emplace_back(vec[i],vec[i+range/2],vec[i+range]);
            }
        }
        cord=std::move(vec);
    }
    void addLine(lint a,lint b){
        int cnt=1;
        while(true){
            lint l=std::get<0>(interval[cnt]),m=std::get<1>(interval[cnt]),r=std::get<2>(interval[cnt]);
            if(n<=cnt){
                if(calc(node[cnt],l)>calc({a,b},l))node[cnt]={a,b};
                break;
            }
            if(calc(node[cnt],l)<calc({a,b},l)&&calc(node[cnt],r)<calc({a,b},r))break;
            if(calc(node[cnt],l)>calc({a,b},l)&&calc(node[cnt],r)>calc({a,b},r)){
                node[cnt]={a,b};
                break;
            }
            if(calc(node[cnt],m)>calc({a,b},m)){
                LP memo=node[cnt];
                node[cnt]={a,b};
                a=memo.first;b=memo.second;
            }
            if(calc(node[cnt],l)>calc({a,b},l))cnt=cnt<<1;
            else cnt=cnt<<1|1;
        }
    }
    lint query(int idx){
        lint x=cord[idx];
        idx+=n;
        lint res=LINF;
        while(idx){
            chmin(res,calc(node[idx],x));
            idx>>=1;
        }
        return res;
    }
};
#line 3 "/Users/kaage/Desktop/ProgrammingWorkspace/library/graph/UnionFind.hpp"
class UnionFind {
protected:
	std::vector<int> par, rank, size;
public:
	UnionFind(unsigned int size) {
		par.resize(size); rank.resize(size, 0); this->size.resize(size, 1);
		rep(i, size) {
			par[i] = i;
		}
	}
	int find(int n) {
		if (par[n] == n)return n;
		return par[n] = find(par[n]);
	}
	void unite(int n, int m) {
		n = find(n);
		m = find(m);
		if (n == m)return;
		if (rank[n] < rank[m]) {
			par[n] = m;
			size[m] += size[n];
		}
		else {
			par[m] = n;
			size[n] += size[m];
			if (rank[n] == rank[m])rank[n]++;
		}
	}
	bool same(int n, int m) {
		return find(n) == find(m);
	}
	int getsize(int n) {
		return size[find(n)];
	}
};
#line 5 "main.cpp"
int n,m,c;
int x[200010],y[200010];
int p[200010],q[200010],r[200010],s[200010];
int b[500010],h[500010];
lint ans[500010];
std::vector<int> cords[2];
std::vector<P> roads[600010];
std::vector<std::pair<int,P>> edges; 
std::vector<LP> costs;
int main(){
    //input
    scanf("%d %d %d",&n,&m,&c);
    rep(i,n){
        scanf("%d %d",x+i,y+i);
        cords[0].emplace_back(x[i]);
        cords[1].emplace_back(y[i]);
    }
    rep(i,m){
        scanf("%d %d %d %d",p+i,q+i,r+i,s+i);
        cords[0].emplace_back(p[i]);
        cords[0].emplace_back(r[i]);
        cords[1].emplace_back(q[i]);
        cords[1].emplace_back(s[i]);
    }
    rep(i,c)scanf("%d %d",b+i,h+i);

    //compression
    std::sort(all(cords[0]));
    std::sort(all(cords[1]));
    cords[0].erase(std::unique(all(cords[0])),cords[0].end());
    cords[1].erase(std::unique(all(cords[1])),cords[1].end());
    rep(i,n){
        x[i]=std::lower_bound(all(cords[0]),x[i])-cords[0].begin();
        y[i]=std::lower_bound(all(cords[1]),y[i])-cords[1].begin();
    }
    rep(i,m){
        p[i]=std::lower_bound(all(cords[0]),p[i])-cords[0].begin();
        q[i]=std::lower_bound(all(cords[1]),q[i])-cords[1].begin();
        r[i]=std::lower_bound(all(cords[0]),r[i])-cords[0].begin();
        s[i]=std::lower_bound(all(cords[1]),s[i])-cords[1].begin();
    }

    RAQRSQ st1(cords[1].size()),st2(cords[0].size());
    std::vector<std::pair<P,P>> queries;

    //roads(x)
    rep(i,n)roads[x[i]].emplace_back(y[i],i);
    rep(i,cords[0].size()){
        if(roads[i].size()>=2){
            queries.push_back({{i,1},{0,0}});
            std::sort(all(roads[i]));
        }
    }
    rep(i,m){
        queries.push_back({{p[i],0},{q[i],s[i]+1}});
        queries.push_back({{r[i],2},{q[i],s[i]+1}});
    }
    std::sort(all(queries));
    for(auto i:queries){
        if(i.first.second==0){
            st1.update(i.second.first,i.second.second,1);
        }
        if(i.first.second==1){
            rep(j,roads[i.first.first].size()-1){
                P l=roads[i.first.first][j],r=roads[i.first.first][j+1];
                lint cost=cords[1][r.first]-cords[1][l.first];
                if(!st1.query(l.first,r.first+1))edges.push_back({cost,{l.second,r.second}});
            }
        }
        if(i.first.second==2){
            st1.update(i.second.first,i.second.second,-1);
        }
    }

    rep(i,cords[0].size())roads[i].clear();
    queries.clear();

    //roads(y)
    rep(i,n)roads[y[i]].emplace_back(x[i],i);
    rep(i,cords[1].size()){
        if(roads[i].size()>=2){
            queries.push_back({{i,1},{0,0}});
            std::sort(all(roads[i]));
        }
    }
    rep(i,m){
        queries.push_back({{q[i],0},{p[i],r[i]+1}});
        queries.push_back({{s[i],2},{p[i],r[i]+1}});
    }
    std::sort(all(queries));
    for(auto i:queries){
        if(i.first.second==0){
            st2.update(i.second.first,i.second.second,1);
        }
        if(i.first.second==1){
            rep(j,roads[i.first.first].size()-1){
                P l=roads[i.first.first][j],r=roads[i.first.first][j+1];
                lint cost=cords[0][r.first]-cords[0][l.first];
                if(!st2.query(l.first,r.first+1))edges.push_back({cost,{l.second,r.second}});
            }
        }
        if(i.first.second==2){
            st2.update(i.second.first,i.second.second,-1);
        }
    }

    //kruskal
    std::sort(all(edges));
    UnionFind uf(n);
    lint cost=0,cnt=n;
    costs.emplace_back(cnt,cost);
    for(auto i:edges){
        if(!uf.same(i.second.first,i.second.second)){
            uf.unite(i.second.first,i.second.second);
            cost+=i.first;
            cnt--;
            costs.emplace_back(cnt,cost);
        }
    }
    std::reverse(all(costs));

    //lct
    std::vector<P> plans;
    rep(i,c)plans.emplace_back(std::min(h[i],n),i);
    std::sort(all(plans));
    std::fill(ans,ans+c,-1);
    std::vector<lint> lctvec(b,b+c);
    std::sort(all(lctvec));
    lctvec.erase(std::unique(all(lctvec)),lctvec.end());
    LiChaoTree lct(lctvec);
    int now=0;
    for(auto i:costs){
        lct.addLine(i.first,i.second);
        while(now<c&&i.first>plans[now].first)now++;
        while(now<c&&i.first==plans[now].first){
            ans[plans[now].second]=lct.query(std::lower_bound(all(lctvec),b[plans[now].second])-lctvec.begin());
            now++;
        }
    }

    rep(i,c)printf("%lld\n",ans[i]);
    return 0;
}

提出情報

提出日時	2020-07-21 21:01:21+0900
問題	1 - 建設事業 (Construction Project)
ユーザ	kaage
言語	C++ (GCC 9.2.1)
得点	100
コード長	18484 Byte
結果	AC
実行時間	1585 ms
メモリ	195156 KiB

コンパイルエラー

/Users/kaage/Desktop/ProgrammingWorkspace/library/other/template.hpp:3: warning: ignoring #pragma target  [-Wunknown-pragmas]
/Users/kaage/Desktop/ProgrammingWorkspace/library/other/template.hpp:4: warning: ignoring #pragma optimize  [-Wunknown-pragmas]
/Users/kaage/Desktop/ProgrammingWorkspace/library/other/template.hpp:5: warning: ignoring #pragma optimize  [-Wunknown-pragmas]
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/IntervalSegTree.hpp: In member function ‘virtual void RAQRMiQ::updf(lint&, const lint&, const unsigned int&)’:
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/IntervalSegTree.hpp:129:56: warning: unused parameter ‘width’ [-Wunused-parameter]
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/IntervalSegTree.hpp: In member function ‘virtual void RAQRMaQ::updf(lint&, const lint&, const unsigned int&)’:
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/IntervalSegTree.hpp:141:56: warning: unused parameter ‘width’ [-Wunused-parameter]
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/IntervalSegTree.hpp: In member function ‘void RUQRMiQ::updf(int&, const int&, const unsigned int&)’:
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/IntervalSegTree.hpp:165:54: warning: unused parameter ‘width’ [-Wunused-parameter]
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/IntervalSegTree.hpp: In member function ‘virtual void RUQRMaQ::updf(lint&, const lint&, const unsigned int&)’:
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/IntervalSegTree.hpp:177:56: warning: unused parameter ‘width’ [-Wunused-parameter]
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/LiChaoTree.hpp: In constructor ‘LiChaoTree::LiChaoTree(std::vector<long long int, std::allocator<long long int> >)’:
/Users/kaage/Desktop/ProgrammingWorkspace/library/data-structure/LiChaoTree.hpp:14:16: warning: comparison of integer expressions of different signedness: ‘int...

ジャッジ結果

セット名

Set 01

Set 02

Set 03

Set 04

Feedback

得点 / 配点

10 / 10

30 / 30

0 / 0

結果

× 8

× 10

× 11

× 28

セット名	テストケース
Set 01	01-01.txt, 01-02.txt, 01-03.txt, 01-04.txt, 01-05.txt, 01-06.txt, 01-07.txt, 01-08.txt
Set 02	02-01.txt, 02-02.txt, 02-03.txt, 02-04.txt, 02-05.txt, 02-06.txt, 02-07.txt, 02-08.txt, 02-09.txt, 02-10.txt
Set 03	03-01.txt, 03-02.txt, 03-03.txt, 03-04.txt, 03-05.txt, 03-06.txt, 03-07.txt, 03-08.txt, 03-09.txt, 03-10.txt
Set 04	04-01.txt, 04-02.txt, 04-03.txt, 04-04.txt, 04-05.txt, 04-06.txt, 04-07.txt, 04-08.txt, 04-09.txt, 04-10.txt, 04-11.txt
Feedback	01-01.txt, 01-02.txt, 01-03.txt, 01-04.txt, 01-05.txt, 01-06.txt, 01-07.txt, 01-08.txt, 02-01.txt, 02-02.txt, 02-03.txt, 02-04.txt, 02-05.txt, 02-06.txt, 02-07.txt, 02-08.txt, 02-09.txt, 02-10.txt, 03-01.txt, 03-02.txt, 03-03.txt, 03-04.txt, 03-05.txt, 03-06.txt, 03-07.txt, 03-08.txt, 03-09.txt, 03-10.txt

ケース名	結果	実行時間	メモリ
01-01.txt	AC	47 ms	20472 KiB
01-02.txt	AC	230 ms	42844 KiB
01-03.txt	AC	233 ms	43084 KiB
01-04.txt	AC	199 ms	37876 KiB
01-05.txt	AC	233 ms	47028 KiB
01-06.txt	AC	234 ms	42980 KiB
01-07.txt	AC	130 ms	36800 KiB
01-08.txt	AC	192 ms	49276 KiB
02-01.txt	AC	1183 ms	84288 KiB
02-02.txt	AC	1185 ms	84340 KiB
02-03.txt	AC	1187 ms	84456 KiB
02-04.txt	AC	1181 ms	84364 KiB
02-05.txt	AC	547 ms	40460 KiB
02-06.txt	AC	236 ms	47208 KiB
02-07.txt	AC	1216 ms	84380 KiB
02-08.txt	AC	349 ms	50960 KiB
02-09.txt	AC	352 ms	50552 KiB
02-10.txt	AC	502 ms	89232 KiB
03-01.txt	AC	599 ms	113236 KiB
03-02.txt	AC	616 ms	112112 KiB
03-03.txt	AC	561 ms	110016 KiB
03-04.txt	AC	430 ms	51628 KiB
03-05.txt	AC	508 ms	117572 KiB
03-06.txt	AC	667 ms	114592 KiB
03-07.txt	AC	597 ms	113020 KiB
03-08.txt	AC	588 ms	112500 KiB
03-09.txt	AC	553 ms	101916 KiB
03-10.txt	AC	467 ms	68624 KiB
04-01.txt	AC	1585 ms	156416 KiB
04-02.txt	AC	935 ms	144504 KiB
04-03.txt	AC	1412 ms	150980 KiB
04-04.txt	AC	499 ms	106348 KiB
04-05.txt	AC	1416 ms	151056 KiB
04-06.txt	AC	515 ms	106492 KiB
04-07.txt	AC	1328 ms	195156 KiB
04-08.txt	AC	1540 ms	155348 KiB
04-09.txt	AC	777 ms	115960 KiB
04-10.txt	AC	732 ms	109392 KiB
04-11.txt	AC	470 ms	69276 KiB