text stringlengths 49 983k |
|---|
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> mypair;
#define rep(i,n) for(int i=0;i<n;i++)
#define chmax(x,y) x= max(x,y)
int main(){
int n;
while(1){
cin>>n;
if(n==0)break;
vector<int> p(n);
vector<vector<mypair> > dp(n+1,vector<mypair> (n*500+1,mypair(-1,-1)) );
dp[0][0] = mypair(0,0);
rep(i,n)cin>>p[i];
rep(i,n)rep(j,500*n+1)if(dp[i][j]!=mypair(-1,-1)){
//if(j>500)cout<<"ok"<<j<<endl;
int coin = dp[i][j].first,cost = dp[i][j].second;
if(j>=(p[i]+500)%1000) chmax(dp[i+1][j-(p[i]+500)%1000],mypair(coin+1,cost-p[i]));
if(1<=p[i]%1000 &&p[i]%1000<=500)chmax(dp[i+1][j+(500-p[i]%1000)],mypair(coin+1,cost-p[i]));
if(500<p[i]%1000)chmax(dp[i+1][j+(1000-p[i]%1000)],mypair(coin,cost-p[i]));
chmax(dp[i+1][j],mypair(coin,cost));
}
mypair ans = mypair(0,0);
rep(i,500*n+1)chmax(ans,dp[n][i]);
cout<<ans.first<<' '<<-ans.second<<endl;
}
return 0;
}
|
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <cstdio>
#include <utility>
using namespace std;
const int MAX = 1e9;
int n, s[101];
pair<int, int> dp[102][101 * 500], result;
void solve(int n){
for(int i = 0; i < n; i++){
scanf("%d", &s[i]);
}
for(int i = 0; i <= n; i++){
for(int j = 0; j < 101 * 500; j++){
dp[i][j] = make_pair(-MAX, 0);
}
}
dp[0][0] = make_pair(0, 0);
for(int i = 1; i <= n; i++){
for(int j = 0; j < 101 * 500; j++){
int r = s[i-1] % 1000;
dp[i][j] = max(dp[i-1][j], dp[i][j]);
if(r == 0){
if(j >= 500){
dp[i][j-500] = max(dp[i][j-500], make_pair(dp[i-1][j].first + 1, dp[i-1][j].second - s[i-1]));
}
}
else if(r <= 500){
dp[i][j+500-r] = max(dp[i][j+500-r], make_pair(dp[i-1][j].first + 1, dp[i-1][j].second - s[i-1]));
}
else{
dp[i][j+1000-r] = max(dp[i][j+1000-r], make_pair(dp[i-1][j].first, dp[i-1][j].second - s[i-1]));
if(j >= r - 500){
dp[i][j+500-r] = max(dp[i][j+500-r], make_pair(dp[i-1][j].first + 1, dp[i-1][j].second - s[i-1]));
}
}
}
/*for(int j = 0; j < 101 * 500; j++){
result = max(result, dp[i][j]);
}
printf("%d %d\n", result.first, result.second);*/
}
int c = 0;
result = make_pair(0, 0);
for(int i = 0; i < 101 * 500; i++){
pair<int, int> a = dp[n][i];
result = max(result, dp[n][i]);
}
printf("%d %d\n", result.first, -result.second);
}
int main(){
while(scanf("%d", &n), n)
solve(n);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
const int N=110;
const int INF=123456789;
int n,p[100];
int dp1[N][50000],dp2[N][50000];
int main()
{
while(scanf(" %d", &n),n)
{
rep(i,n) scanf(" %d", &p[i]);
fill(dp1[0],dp1[N],-INF);
fill(dp2[0],dp2[N],INF);
dp1[0][0]=0;
dp2[0][0]=0;
rep(i,n)
{
rep(j,50000)
{
// ??????
// ???????????????????????????
int r = (1000-p[i]%1000)%1000;
int add=0;
if(r>=500)
{
add=1;
r-=500;
}
if(j+r<50000)
{
if(dp1[i+1][j+r] < dp1[i][j]+add)
{
dp1[i+1][j+r] = dp1[i][j]+add;
dp2[i+1][j+r] = dp2[i][j]+p[i];
}
else if(dp1[i+1][j+r] == dp1[i][j]+add)
{
dp2[i+1][j+r] = min(dp2[i+1][j+r],dp2[i][j]+p[i]);
}
}
// ?°?????????????
int need = p[i]%1000;
if(need>=500) need-=500;
else need+=500;
if(need<=j)
{
if(dp1[i+1][j-need] < dp1[i][j]+1)
{
dp1[i+1][j-need] = dp1[i][j]+1;
dp2[i+1][j-need] = dp2[i][j]+p[i];
}
else if(dp1[i+1][j-need] == dp1[i][j]+1)
{
dp2[i+1][j-need] = min(dp2[i+1][j-need],dp2[i][j]+p[i]);
}
}
// ????????????
if(dp1[i+1][j] < dp1[i][j])
{
dp1[i+1][j] = dp1[i][j];
dp2[i+1][j] = dp2[i][j];
}
else if(dp1[i+1][j] == dp1[i][j])
{
dp2[i+1][j] = min(dp2[i+1][j],dp2[i][j]);
}
}
}
int x=0;
rep(i,50000) x = max(x,dp1[n][i]);
int y=INF;
rep(i,50000)
{
if(dp1[n][i] == x) y = min(y,dp2[n][i]);
}
printf("%d %d\n", x,y);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define long long long
using pi = pair<int, int>;
pi dp[500][105];
pi before[500][105];
const int inf = 1145141919;
pi ch(pi a, pi b)
{
if (a.second >= inf) {
return b;
}
else if(b.second >= inf)
{
return a;
}
if(a.first == b.first)
{
if(a.second < b.second) {
return a;
}
else{
return b;
}
}
else
{
if (a.first > b.first)
return a;
else
return b;
}
}
int main()
{
while (true)
{
int N;
cin >> N;
if (N == 0)
return 0;
rep(i, 500) rep(j, 105)
{
dp[i][j] = pi(0, inf);
}
dp[0][0] = pi(0, 0);
rep(t, N)
{
int P;
cin >> P;
swap(dp, before);
rep(i, 500) rep(j, 105)
{
dp[i][j] = pi(0, inf);
}
int X = P % 1000;
if (0 < X && X <= 500)
{
//にせ500を使わない
//before[i][j][k]から遷移
rep(i, 500) rep(j, 103)
{
int k = before[i][j].first;
int cost = before[i][j].second;
//買わない
dp[i][j] = ch(before[i][j], dp[i][j]);
//買う
int tsuri = (1000 - X) % 500;
int next = i + tsuri;
int nise = 0;
if (next >= 500)
{
next -= 500;
nise++;
}
dp[next][j + nise] = ch(dp[next][j + nise], pi(k + 1, cost + P));
}
}
else
{
//にせ500を使える
rep(i, 500) rep(j, 103)
{
int k = before[i][j].first;
int cost = before[i][j].second;
//買わない
dp[i][j] = ch(before[i][j], dp[i][j]);
//買うけどにせ500使わない
int tsuri = (1000 - X) % 500;
int next = i + tsuri;
int shin = 0;
if (next >= 500)
{
next -= 500;
shin++;
}
dp[next][j] = ch(dp[next][j], pi(k + shin, cost + P));
// にせ500使う
if (j > 0)
{
tsuri = (1500 - X) % 500;
next = i + tsuri;
int nise = 0;
if (next >= 500)
{
next -= 500;
nise++;
}
dp[next][j - 1 + nise] = ch(dp[next][j - 1 + nise], pi(k + 1, cost + P));
}
}
}
// rep(i, 500) rep(j, 105) rep(k, 105)
// {
// if(dp[i][j][k] < inf)
// {
// cout << t << " " << i << " " << j << " " << k << " " << dp[i][j][k] << endl;
// }
// }
}
pi ans = pi(0, 0);
rep(i, 500)
{
rep(j, 105)
{
ans = ch(ans, dp[i][j]);
}
}
cout << ans.first << " " << ans.second << "\n";
}
}
|
#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll INF = 1e13;
//vector<vector<pair<ll, ll>>> dp(100 + 2, vector<pair<ll, ll>>(50700)); // dp[i][j] := i日目にj円持ってるときに持ってる500円の枚数と支払った金額
pair<ll, ll> dp[200][50700];
int main() {
ll n, i, j;
while(cin >> n, n) {
vector<ll> p(n);
for(i = 0; i < n; i++) {
cin >> p[i];
}
pair<ll, ll> x = make_pair(0LL, INF);
for(i = 0; i <= n; i++) {
for(j = 0; j <= 50100; j++) {
dp[i][j] = x;
}
}
dp[0][0] = make_pair(0LL, 0LL);
for(i = 0; i < n; i++) {
for(j = 0; j < 50000; j++) {
if(dp[i][j].second == INF) continue;
if(dp[i][j].first > dp[i + 1][j].first)
dp[i + 1][j] = dp[i][j]; //何もしないとき
else if(dp[i][j].first == dp[i + 1][j].first) {
dp[i + 1][j].second = min(dp[i + 1][j].second, dp[i][j].second);
}
// 買うとき
ll otsuri = (1000 - (p[i] % 1000)) % 1000; // 小銭を使わないで得られるお金
if(otsuri >= 500) {
// cerr << j+otsuri-500 << endl;
if(dp[i + 1][j + otsuri - 500].first < dp[i][j].first + 1)
dp[i + 1][j + otsuri - 500] = make_pair(dp[i][j].first + 1, dp[i][j].second + p[i]);
else if(dp[i + 1][j + otsuri - 500].first == dp[i][j].first + 1)
dp[i + 1][j + otsuri - 500].second = min(dp[i + 1][j + otsuri - 500].second, dp[i][j].second + p[i]);
} else {
ll must = (p[i] % 1000) - 500; // 500円を得るのに最低必要な小銭
if(must == -500) must = 500;
if(must <= j) {
if(dp[i + 1][j - must].first < dp[i][j].first + 1)
dp[i + 1][j - must] = make_pair(dp[i][j].first + 1, dp[i][j].second + p[i]);
else if(dp[i + 1][j - must].first == dp[i][j].first + 1)
dp[i + 1][j - must].second = min(dp[i + 1][j - must].second, dp[i][j].second + p[i]);
}
//とりあえずお金を稼ぐ
if(dp[i + 1][j + otsuri].first < dp[i][j].first)
dp[i + 1][j + otsuri] = make_pair(dp[i][j].first, dp[i][j].second + p[i]);
else if(dp[i + 1][j + otsuri].first == dp[i][j].first)
dp[i + 1][j + otsuri].second = min(dp[i][j].second + p[i], dp[i + 1][j + otsuri].second);
}
}
}
pair<ll, ll> ret(0LL, INF);
for(i = 0; i < 50000; i++) {
if(dp[n][i].first > ret.first) {
ret = dp[n][i];
} else if(dp[n][i].first == ret.first) {
ret.second = min(ret.second, dp[n][i].second);
}
}
cout << ret.first << " " << ret.second << endl;
//cout << dp[2][200].first << " " << dp[2][200].second << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
#define fi first
#define se second
typedef long long ll;
using namespace std;
pair<int,int> dp[2][200001];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
while(cin>>n,n){
int a[201];
fill(a,a+201,0);
for(int i=0;i<n;i++){
cin>>a[i];
}
for(int i=0;i<=200000;i++)dp[0][i]=make_pair(-1,0);
dp[0][0]=make_pair(0,0);
for(int i=0;i<n;i++){
for(int j=0;j<=200000;j++)dp[(i+1)&1][j]=make_pair(-1,0);
for(int j=0;j<=200000;j++){
if(dp[i&1][j].fi==-1)continue;
int tmp=a[i]%1000;
if(tmp<=500 && tmp>=1)
dp[(i+1)&1][j+500-tmp]=max(make_pair(dp[i&1][j].fi+1,dp[i&1][j].se-a[i]),dp[(i+1)&1][j+500-tmp]);
else{
int pay=(tmp+500)%1000;
dp[(i+1)&1][j]=max(dp[(i+1)&1][j],dp[i&1][j]);
if(pay<=j)
dp[(i+1)&1][j-pay]=max(make_pair(dp[i&1][j].fi+1,dp[i&1][j].se-a[i]),dp[(i+1)&1][j-pay]);
int pay2=(1000-tmp)%1000;
dp[(i+1)&1][j+pay2]=max(make_pair(dp[i&1][j].fi,dp[i&1][j].se-a[i]),dp[(i+1)&1][j+pay2]);
}
}
}
pair<int,int> ans=make_pair(0,0);
for(int i=0;i<=200000;i++){
ans=max(ans,dp[n&1][i]);
}
cout<<ans.fi<<" "<<-ans.se<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
return is >> p.FF >> p.SS;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
return os << p.FF << " " << p.SS;
}
template<class T>
void maxi(T& x, T y){
if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
if(x > y) x = y;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9+7;
const int INF = 1e8;
const int MX = 500*100+10;
PII dp[2][MX];
int main(){
int N;
while(scanf("%d",&N), N){
VI ps(N);
REP(i,N) scanf("%d", &ps[i]);
fill((PII*)dp, (PII*)dp+2*MX, MP(0,-INF));
int crt = 0, nxt = 1;
dp[crt][0] = MP(0, -0);
REP(i,N){
REP(x,MX)
dp[nxt][x] = dp[crt][x];
int p = ps[i] % 1000;
if(p == 0){
for(int x=500;x<MX;++x){
PII tmp = dp[crt][x];
if(tmp.SS <= -INF) continue;
tmp.FF++;
tmp.SS -= ps[i];
maxi(dp[nxt][x-500], tmp);
}
}
else if(p <= 500){
for(int x=0;x<MX;++x){
PII tmp = dp[crt][x];
if(tmp.SS <= -INF) continue;
tmp.FF++;
tmp.SS -= ps[i];
maxi(dp[nxt][x+500-p], tmp);
}
}
else{
int p_ = p - 500;
for(int x=0;x<MX;++x){
if(x >= p_){
PII tmp = dp[crt][x];
if(tmp.SS > -INF){
tmp.FF++;
tmp.SS -= ps[i];
maxi(dp[nxt][x-p_], tmp);
}
}
PII tmp = dp[crt][x];
if(tmp.SS <= -INF) continue;
tmp.SS -= ps[i];
maxi(dp[nxt][x+1000-p], tmp);
}
}
swap(crt, nxt);
}
PII ans(0,-0);
REP(x,MX){
maxi(ans, dp[crt][x]);
}
printf("%d %d\n", ans.FF, -ans.SS);
}
return 0;
} |
#include <iostream>
#include <vector>
#include <array>
#include <list>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <tuple>
#include <memory>
#include <cmath>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <numeric>
#include <climits>
#include <cfloat>
#include <cassert>
#include <random>
#include <set>
void renew(std::pair<int, int>& a, const std::pair<int, int> pair) {
if (a.first < pair.first) {
a = pair;
}
else if (a.first == pair.first && a.second > pair.second) {
a = pair;
}
}
int main() {
while (true) {
int n; std::cin >> n; if (n == 0) break;
std::vector<int> price(n); for (auto& p : price) std::cin >> p;
std::vector<std::vector<std::pair<int, int>>> memo(2, std::vector<std::pair<int, int>>(n * 500 + 1, std::make_pair(-1, 0))); memo[0][0].first = 0;
for (const auto p : price) {
if (p % 1000 == 0) {
for (auto i = 0; i < memo[0].size(); ++i) {
if (memo[0][i].first >= 0) {
renew(memo[1][i], memo[0][i]);
if (i >= 500) {
renew(memo[1][i - 500], std::make_pair(memo[0][i].first + 1, memo[0][i].second + p));
}
}
}
}
else if (p % 1000 == 500) {
for (auto i = 0; i < memo[0].size(); ++i) {
if (memo[0][i].first >= 0) {
renew(memo[1][i], memo[0][i]);
renew(memo[1][i], std::make_pair(memo[0][i].first + 1, memo[0][i].second + p));
}
}
}
else if (p % 1000 <= 500) {
const auto diff = 500 - p % 500;
for (auto i = 0; i < memo[0].size(); ++i) {
if (memo[0][i].first >= 0 ) {
renew(memo[1][i], memo[0][i]);
if (i + diff < memo[1].size())
renew(memo[1][i + diff], std::make_pair(memo[0][i].first + 1, memo[0][i].second + p));
}
}
}
else {
const auto diff = 500 - p % 500;
for (auto i = 0; i < memo[0].size(); ++i) {
if (memo[0][i].first >= 0) {
renew(memo[1][i], memo[0][i]);
if (i >= p % 500) {
renew(memo[1][i - p % 500], std::make_pair(memo[0][i].first + 1, memo[0][i].second + p));
}
if (i + diff < memo[1].size()) {
renew(memo[1][i + diff], std::make_pair(memo[0][i].first, memo[0][i].second + p));
}
}
}
}
std::swap(memo[0], memo[1]);
}
const auto res = *std::max_element(memo.front().begin(), memo.front().end(), [](std::pair<int, int>& a, const std::pair<int, int>& b) {return a.first == b.first ? a.second > b.second : a.first < b.first; });
std::cout << res.first << ' ' << res.second << '\n';
}
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(int argc, char *argv[])
{
const int BIG = 1000000;
const int CMAX = 10000;
for(;;) {
int n;
cin >> n;
if(n == 0) break;
vector<int> ps;
for(int i = 0; i < n; i++) {
int p; cin >> p; ps.push_back(p);
}
// shop : at most 100
// change : at most 49900... too much?
// # of 500 got so far : at most 100
// value : minimum payment
vector<vector<int>> dp(CMAX+1, vector<int>(101, BIG));
vector<vector<int>> dpnew(CMAX+1, vector<int>(101, BIG));
dpnew[0][0] = 0;
int cmax = 0;
for(int i = 0; i < n; i++) {
const int ii = i + 1;
for(int j = 0; j <= cmax; j++) { // not buying
for(int k = 0; k <= i; k++) {
dp[j][k] = dpnew[j][k];
}
}
// buying
const int p = ps[i] % 1000;
if(p != 0 && p <= 500) { // got 500!
for(int j = 0; j <= cmax; j++) {
const int jj = min(j + 500 - p, CMAX);
cmax = min(max(cmax, jj), CMAX);
for(int k = 0; k <= i; k++) {
const int kk = k + 1;
dpnew[jj][kk] = min(dpnew[jj][kk], dp[j][k] + ps[i]);
}
}
} else {
// get 500 if possible!
const int q = (p == 0 ? 1000 : p) - 500;
for(int j = 0; j <= cmax; j++) {
if(j >= q) {
const int jj = j - q;
for(int k = 0; k <= i; k++) {
const int kk = k + 1;
dpnew[jj][kk] = min(dpnew[jj][kk], dp[j][k] + ps[i]);
}
} else { // get change
const int jj = j + 1000 - p;
cmax = min(max(cmax, jj), CMAX);
if( jj < 1000) {
for(int k = 0; k <= i; k++) {
const int kk = k;
dpnew[jj][kk] = min(dpnew[jj][kk], dp[j][k] + ps[i]);
}
}
}
}
}
}
for(int k = 100; k >= 0; k--) {
int p = BIG;
for(int j = 0; j <= cmax; j++) {
p = min(p, dpnew[j][k]);
}
if(p != BIG) {
cout << k << " " << p << endl;
break;
}
}
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int N;
pair<int, int> dp[100][50000];
vector<int> P;
pair<int, int> dfs(int idx, int ch) {
if (idx == N) return make_pair(0, 0);
if (dp[idx][ch].first >= 0) return dp[idx][ch];
// 買わない
dp[idx][ch] = dfs(idx + 1, ch);
int p = P[idx] % 1000;
if (p == 0) {
if (ch >= 500) {
// 小銭から500円玉を回収
auto ret = dfs(idx + 1, ch - 500);
ret.first += 1, ret.second -= P[idx];
dp[idx][ch] = max(dp[idx][ch], ret);
}
} else if (p <= 500) {
// 1000円投げて500円玉を回収
auto ret = dfs(idx + 1, ch + 1000 - p - 500);
ret.first += 1, ret.second -= P[idx];
dp[idx][ch] = max(dp[idx][ch], ret);
} else {
// 1000円で小銭を回収
auto ret = dfs(idx + 1, ch + 1000 - p);
ret.second -= P[idx];
dp[idx][ch] = max(dp[idx][ch], ret);
int need = p - 500;
if (need <= ch) {
// 小銭を投げて500円玉を回収
auto ret = dfs(idx + 1, ch - need);
ret.first += 1;
ret.second -= P[idx];
dp[idx][ch] = max(dp[idx][ch], ret);
}
}
return dp[idx][ch];
}
bool solve() {
fill(dp[0], dp[100], make_pair(-1, -1));
cin >> N;
if (N == 0) return false;
P.resize(N);
for (auto& p : P) {
cin >> p;
}
auto ans = dfs(0, 0);
cout << ans.first << " " << -ans.second << endl;
return true;
}
int main() {
while (solve()) {}
return 0;
}
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
using namespace std;
#define IINF INT_MAX
int n,p[110],dp[110][100010];
int main() {
while( cin >> n, n ) {
rep(i,n) cin >> p[i];
int limit = (n * 999) + 1;
rep(i,n+1) rep(j,limit) dp[i][j] = IINF;
dp[0][0] = 0;
int maxi = -IINF, mini = IINF;
rep(i,n) {
for(int j=n;j>=0;--j) {
for(int k=min((i+1)*999+1,limit)-1;k>=0;--k) {
if( dp[j][k] == IINF ) continue;
int rem = ( 1000 - p[i] % 1000 ) + k;
if( p[i] % 1000 == 0 ) rem = k;
if( rem >= 500 ) {
assert( rem - 500 >= 0 && rem - 500 < limit);
dp[j+1][rem-500] = min(dp[j+1][rem-500],
dp[j][k]+p[i]);
if( maxi < j + 1 ) maxi = j + 1, mini = dp[j+1][rem-500];
else if( maxi == j + 1 ) mini = min(mini,dp[j+1][rem-500]);
} else {
assert( 0 <= rem && rem < limit );
dp[j][rem] = min(dp[j][rem],dp[j][k]+p[i]);
}
dp[j][k] = min(dp[j][k],dp[j][k]);
}
}
}
if( maxi == -IINF ) maxi = mini = 0;
cout << maxi << " " << mini << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
// dp[i][500yen][num_1000yen] := remain ([i] is deleted)
int dp[128][512];
int n;
int P[128];
void init() {
for(int j = 0; j < 128; ++j) {
for(int k = 0; k < 512; ++k) {
dp[j][k] = -1;
}
}
}
int main() {
for(;;) {
init();
scanf("%d", &n);
if( n == 0 ) break;
for(int i = 0; i < n; ++i) {
scanf("%d", &P[i]);
}
dp[0][0] = 0;
for(int i = 0; i < n; ++i) {
for(int j = i; j >= 0; --j) {
for(int k = 512 - 1; k >= 0; --k) {
if( dp[j][k] == -1 ) continue;
int n1kyen = (P[i] + 999) / 1000;
int rem = dp[j][k] + n1kyen * 1000 - P[i];
int next_num500yen = j + (rem >= 500 ? 1 : 0);
int next_num1kyen = k + n1kyen;
int next_rem = rem >= 500 ? rem - 500 : rem;
int& next = dp[next_num500yen][next_num1kyen];
next = std::max(next, next_rem);
}
}
}
int res = (1 << 28);
int max = -1;
for(int j = n; j >= 0; --j) {
for(int k = 0; k < 512; ++k) {
if( dp[j][k] == -1 ) continue;
int cost = k * 1000 - 500 * j - dp[j][k];
res = std::min(res, cost);
}
if( res != (1 << 28) ) {
max = j;
break;
}
}
printf("%d %d\n", max, res);
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
int dp[101][101][700];
signed main(){
int n;
while(cin>>n,n){
int p[n];
for(int i=0;i<n;i++) cin>>p[i];
memset(dp,-1,sizeof(dp));
dp[0][0][0]=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
for(int k=0;k<650;k++){
if(dp[i][j][k]<0) continue;
for(int a=0;a<7;a++){
int tmp=0,flg=0;
tmp=1000*a-p[i];
if(tmp>=0) tmp%=1000;
if(dp[i][j][k]+tmp<0) continue;
if(dp[i][j][k]+tmp>=500){
tmp-=500;
flg=1;
}
dp[i+1][j+flg][k+a]=max(dp[i+1][j+flg][k+a],dp[i][j][k]+tmp);
}
dp[i+1][j][k]=max(dp[i+1][j][k],dp[i][j][k]);
}
}
}
/*//
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
for(int k=0;k<650;k++){
if(dp[i][j][k]<0) continue;
cout<<i<<" "<<j<<" "<<k<<" "<<dp[i][j][k]<<endl;
}
}
}
//*/
int c=0,s=0;
for(int j=0;j<=n;j++){
for(int k=0;k<650;k++){
if(dp[n][j][k]<0) continue;
int tmp=1000*k-500*j-dp[n][j][k];
if(c<j) c=j,s=tmp;
if(c==j) s=min(s,tmp);
}
}
cout<<c<<" "<<s<<endl;
}
return 0;
} |
#include<iostream>
#include<vector>
#include<utility>
using namespace std;
int main(int argc, char *argv[])
{
const int BIG = 1000000;
const int CMAX = 50000;
for(;;) {
int n;
cin >> n;
if(n == 0) break;
vector<int> ps;
for(int i = 0; i < n; i++) {
int p; cin >> p; ps.push_back(p);
}
// shop : at most 100
// change : at most 49900...
// value : (-(# 500 yen so far), minimum payment)
//
// NOTE: the first element is negated.
//
// for the same amount of change, pairs (k1, p1) and (k2, p2),
// if k1 < k2 then (k2, p2) has no chance to be the best solution
// because # of coins to be got depends only on the current change
// so, we can use lexicographical order of pairs here.
vector<pair<int,int>> dp(CMAX+1, pair<int,int>(BIG, BIG));
vector<pair<int,int>> dpnew(CMAX+1, pair<int,int>(BIG, BIG));
dpnew[0] = make_pair(0, 0);
int cmax = 0;
for(int i = 0; i < n; i++) {
// not buying
for(int j = 0; j <= cmax; j++) {
dp[j] = dpnew[j];
}
// buying
for(int j = 0; j <= cmax; j++) {
if(dp[j].first > 0) continue;
const int p = ps[i] % 1000;
if(p != 0 && p <= 500) { // got 500!
const int jj = min(j + 500 - p, CMAX);
cmax = min(max(cmax, jj), CMAX);
pair<int,int> dd(dp[j].first - 1, dp[j].second + ps[i]);
if(dd < dpnew[jj]) {
dpnew[jj] = dd;
}
} else {
// get 500 if possible!
const int q = (p == 0 ? 1000 : p) - 500;
if(j >= q) {
const int jj = j - q;
pair<int,int> dd(dp[j].first - 1, dp[j].second + ps[i]);
if(dd < dpnew[jj]) {
dpnew[jj] = dd;
}
} else { // get change
const int jj = (j + 1000 - p) % 1000;
cmax = min(max(cmax, jj), CMAX);
if( jj <= CMAX) {
pair<int,int> dd(dp[j].first, dp[j].second + ps[i]);
if(dd < dpnew[jj]) {
dpnew[jj] = dd;
}
}
}
}
}
}
pair<int,int> dd(BIG, BIG);
for(int j = 0; j <= cmax; j++) {
if(dpnew[j] < dd) {
dd = dpnew[j];
}
}
cout << -dd.first << " " << dd.second << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
pair<int, int> dp[109][50009]; int n, x[109], g[109];
int main() {
while (true) {
cin >> n; if (n == 0) break;
for (int i = 1; i <= n; i++) { cin >> x[i]; g[i] = x[i]; x[i] %= 1000; }
for (int i = 1; i <= n + 1; i++) { for (int j = 0; j <= n * 500; j++) dp[i][j] = make_pair(-1, -1); }
dp[1][0] = make_pair(0, 0);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n * 500; j++) {
if (dp[i][j] == make_pair(-1, -1)) continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
if (x[i] == 0) {
// 何もできない
if (j >= 500) dp[i + 1][j - 500] = max(dp[i + 1][j - 500], make_pair(dp[i][j].first + 1, dp[i][j].second - g[i]));
}
else if (x[i] >= 1 && x[i] <= 500) {
// 1000 円支払う
dp[i + 1][j + (1000 - x[i]) % 500] = max(dp[i + 1][j + (1000 - x[i]) % 500], make_pair(dp[i][j].first + 1, dp[i][j].second - g[i]));
}
else {
// 1000 円支払う
if (j - (x[i] - 500) >= 0) {
dp[i + 1][j - (x[i] - 500)] = max(dp[i + 1][j - (x[i] - 500)], make_pair(dp[i][j].first + 1, dp[i][j].second - g[i]));
}
else {
dp[i + 1][j + (1000 - x[i]) % 500] = max(dp[i + 1][j + (1000 - x[i]) % 500], make_pair(dp[i][j].first, dp[i][j].second - g[i]));
}
}
}
}
pair<int, int>maxn = make_pair(-1, -1);
for (int i = 0; i <= 50000; i++) maxn = max(maxn, dp[n + 1][i]);
cout << maxn.first << " " << -maxn.second << endl;
}
return 0;
}
|
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#define fi first
#define sc second
#define mp make_pair
pair<int,int> dp[105][100005];
int n,p[105];
void chh(pair<int,int> &a,pair<int,int> &b){
if(a.fi < b.fi) a = b;
else if(a.fi == b.fi) a.sc = min(a.sc,b.sc);
}
int main(){
while(1){
cin>>n; if(!n) return 0;
for(int i=1;i<=n;i++) cin>>p[i];
for(int i=0;i<105;i++) for(int j=0;j<100005;j++) dp[i][j] = mp(-10000,100000000);
dp[0][0] = mp(0,0);
for(int i=0;i<n;i++){
for(int j=0;j<=1000*i;j++){
if(dp[i][j].fi < 0) continue; //cout <<i << " " <<j<< endl;
if(dp[i+1][j].fi < dp[i][j].fi) dp[i+1][j] = dp[i][j];
else if(dp[i+1][j].fi == dp[i][j].fi) dp[i+1][j].sc = min(dp[i+1][j].sc,dp[i][j].sc);
if(p[i+1]%1000 == 0){
if(j>=500){
pair<int,int> Q=mp(dp[i][j].fi+1,dp[i][j].sc+p[i+1]) ;
chh(dp[i+1][j-500],Q);
}
}
else if(p[i+1]%1000 <= 500){
pair<int,int> Q=mp(dp[i][j].fi+1,dp[i][j].sc+p[i+1]) ;
chh(dp[i+1][j+500-(p[i+1]%1000)],Q);
}
else{
if(j+500-(p[i+1]%1000)>=0){
pair<int,int> Q=mp(dp[i][j].fi+1,dp[i][j].sc+p[i+1]) ;
chh(dp[i+1][j+500-(p[i+1]%1000)],Q);
}
pair<int,int> Q=mp(dp[i][j].fi,dp[i][j].sc+p[i+1]) ;
chh(dp[i+1][j+1000-(p[i+1]%1000)],Q);
}
}
}
pair<int,int> ans = mp(-10000,100000000);
for(int i=0;i<=n;i++){
for(int j=0;j<100005;j++){
if(ans.fi < dp[i][j].fi) ans = dp[i][j];
else if(ans.fi == dp[i][j].fi) ans.sc = min(ans.sc,dp[i][j].sc);
}}
cout <<ans.fi<<" " << ans.sc << endl;
}
} |
#include<iostream>
#include<algorithm>
using namespace std;
typedef pair<int, int> Pi;
int N, P[100];
Pi dp[2][501 * 100];
//dpは 枚数 コスト の順番で持つ
const int INF = 1145141919;
void update(Pi& a, Pi b) {
if (a.first < b.first)a = b;
else if (a.first > b.first);
else {
if (a.second > b.second)a = b;
}
}
int main() {
while (1) {
cin >> N;
if (N == 0)break;
for (int i = 0; i < N; i++)cin >> P[i];
for (int i = 0; i < 2; i++)for (int j = 0; j <= 500 * 100; j++)dp[i][j] = Pi(0, INF);
auto now = dp[0], next = dp[1];
now[0] = Pi(0, 0);
for (int i = 0; i < N; i++) {
for (int j = 0; j <= N * 500; j++) {
if (now[j] == Pi(0, INF))continue;
if (1 <= P[i] % 1000 && P[i] % 1000 <= 500) {
//千円札で払えばかならず１枚手に入る
update(next[j + 500 - (P[i] % 1000)], Pi(now[j].first + 1, now[j].second + P[i]));
}
else if (P[i] % 1000 == 0) {
//何もしない
next[j] = now[j];
//1000円札＋小銭で、五百円玉がおつりででるように払う
if (j >= 500) {
update(next[j - 500], Pi(now[j].first + 1, now[j].second + P[i]));
}
}
else {
//何もしない
next[j] = now[j];
//千円札で買って、小銭を増やす
update(next[j + (1000 - (P[i] % 1000))], Pi(now[j].first, now[j].second + P[i]));
//小銭を使って、五百円玉がおつりででるように払う
if (j >= (P[i] % 1000) - 500) {
update(next[j - (P[i] % 1000 - 500)], Pi(now[j].first + 1, now[j].second + P[i]));
}
}
}
swap(now, next);
}
int coin = 0, cost = 0;
for (int i = 0; i <= N * 500; i++) {
if (now[i] != Pi(INF, INF)) {
if (coin < now[i].first)coin = now[i].first, cost = now[i].second;
else if (coin == now[i].first && cost > now[i].second)cost = now[i].second;
}
}
cout << coin << " " << cost << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
#define REP(i,x,n) for(int i = x; i < n; i++)
const int N = 1e5+10;
void solve(int n) {
vector<int> a(n);
REP(i, 0, n) cin >> a[i];
using P = pair<int, int>;
P dp[2][N];
REP(i, 0, 2) REP(j, 0, N) dp[i][j] = P(-1000,0);
dp[0][0] = P(0,0);
REP(i, 0, n) {
int tmp = a[i] % 1000;
if (tmp == 0) tmp = 1000;
REP(j, 0, N) dp[(i+1)&1][j] = P(-1000,0);
REP(j, 0, 100001) {
if (tmp <= 500) {
if (j + 500 - tmp < N) dp[(i + 1) & 1][j + 500 - tmp] = max(dp[(i + 1) & 1][j + 500 - tmp], P(dp[i & 1][j].first+1,dp[i&1][j].second-a[i]));
}
else{
if (j - (tmp - 500) >= 0) dp[(i + 1)&1][j - (tmp - 500)] = max(dp[(i + 1)&1][j - (tmp - 500)], P(dp[i & 1][j].first + 1, dp[i & 1][j].second - a[i]));
if(j+1000-tmp < N) dp[(i + 1)&1][j + 1000 -tmp] = max(dp[(i + 1)&1][j + 1000 - tmp], P(dp[i & 1][j].first, dp[i & 1][j].second - a[i]));
}
dp[(i + 1) & 1][j] = max(dp[(i + 1) & 1][j], dp[i & 1][j]);
}
}
P ans = P(0,0);
REP(i, 0, N) ans = max(ans, dp[n&1][i]);
cout << ans.first << " " << -ans.second << endl;
}
int main() {
int n;
while (cin >> n, n) {
solve(n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<int(n);++i)
#define rep1(i,n) for(int i=1;i<=int(n);++i)
#define all(a) a.begin(),a.end()
#define lb(s,x) lower_bound(all(s),x)-s.begin()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define INF 1e9
typedef long long ll;
#define updmin(dp,x) (dp=(dp == 0 ? x : min(dp,x)))
int main(void){
int n;
while(cin>>n, n){
vector<int> p(n);
rep(i,n) cin>>p[i];
// vector<map<int,int>> dp(n+1); // dp[get][coin] = pay
vector<vector<int>> dp(n+1, vector<int>(500*n,INF));
dp[0][0] = 0;
int coin_max = 0;
rep(i,n){
for(int k = i; k >= 0; k--){
// for(auto itr = dp[k].rbegin(); itr != dp[k].rend(); ++itr){
for(int coin = 500*n-1; coin>=0; coin--){
if(dp[k][coin] == INF) continue;
// int coin = itr->first;
// coin_max = max(coin_max, coin);
int pay = dp[k][coin];
// int pay = itr->second;
int mod = p[i]%500;
if(p[i]%1000 == 0){
if(coin>=500) updmin(dp[k+1][coin-500], pay+p[i]);
}else if(p[i]%1000 == 500){
updmin(dp[k+1][coin], pay+p[i]);
}else if(p[i]%1000 <= 500){
// if(mod+500<=coin){
// updmin(dp[k+1][coin-500-mod], pay+p[i]);
// }else{
updmin(dp[k+1][coin+500-mod], pay+p[i]);
// }
}else if(mod <= coin){
updmin(dp[k+1][coin-mod], pay+p[i]);
}else{
updmin(dp[k][coin+500-mod], pay+p[i]);
}
}
}
}
for(int i = n; i>=0; i--){
// if(dp[i].size()){
int res = INF;
for(auto itr : dp[i]){
// res = min(res,itr.second);
res = min(res,itr);
}
if(res != INF){
cout<<i<<" "<<res<<endl;
break;
}
// }
}
// debug(coin_max);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<int(n);++i)
#define rep1(i,n) for(int i=1;i<=int(n);++i)
#define all(a) a.begin(),a.end()
#define lb(s,x) lower_bound(all(s),x)-s.begin()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define INF 1e9
typedef long long ll;
#define updmax(dp,x) dp=(dp.first == 0 ? x : max(dp,x))
using P = pair<int,int>;
int main(void){
int n;
while(cin>>n, n){
vector<int> p(n);
rep(i,n) cin>>p[i];
map<int,P> cur; // cur[coin] = <get,pay>
cur[0] = {0,0};
rep(i,n){
map<int,P> nxt;
for(auto &itr : cur){
int coin = itr.first;
int k = itr.second.first;
int pay = itr.second.second;
updmax(nxt[coin], P(k,pay));
pay -= p[i];
int mod = p[i]%500;
if(p[i]%1000 == 0){
if(coin>=500) updmax(nxt[coin-500], P(k+1,pay));
}else if(p[i]%1000 == 500){
updmax(nxt[coin], P(k+1,pay));
}else if(p[i]%1000 <= 500){
updmax(nxt[coin+500-mod],P(k+1, pay));
}else if(mod <= coin){
updmax(nxt[coin-mod], P(k+1,pay));
}else{
updmax(nxt[coin+500-mod], P(k,pay));
}
}
cur = move(nxt);
}
P res = {0,0};
for(auto itr : cur){
res = max(res,itr.second);
}
cout<<res.first<<" "<<-res.second<<endl;
}
return 0;
}
|
// #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;
using ll = long long int;
using int64 = long long int;
template<typename T> void chmax(T &a, T b) {a = max(a, b);}
template<typename T> void chmin(T &a, T b) {a = min(a, b);}
template<typename T> void chadd(T &a, T b) {a = a + b;}
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const int INF = 1LL << 29;
const ll LONGINF = 1LL << 60;
const ll MOD = 1000000007LL;
const int MAXP = 100 * 500;
pair<int, int> dp[3][MAXP];
int solve_testcase() {
int N; scanf("%d", &N);
if(N == 0) return 1;
vector<int> P(N);
for(int i=0; i<N; i++) scanf("%d", &P[i]);
auto update = [](pair<int, int> &A, pair<int, int> &B) {
if(A.first < B.first) A = B;
else if(A.first == B.first and A.second > B.second) A = B;
};
const pair<int, int> NIL(-1, INF);
fill(dp[0], dp[2], NIL);
dp[0][0] = make_pair(0, 0);
for(int i=0; i<N; i++) {
int p = P[i] % 1000;
int cur = i % 2, nxt = 1 ^ cur;
for(int j=0; j<MAXP; j++) {
if(dp[cur][j] == NIL) continue;
// 買わない
update(dp[nxt][j], dp[cur][j]);
{
// 買う (小銭を調整しない)
{
int x = -p, g = 0;
if(x < 0) x += 1000;
g += (x >= 500);
x %= 500;
pair<int, int> ndp(dp[cur][j].first + g,
dp[cur][j].second + P[i]);
update(dp[nxt][j+x], ndp);
}
// 買う (小銭から 500 円使う)
if(j >= 500) {
int x = 500 - p, g = 0;
if(x < 0) x += 1000;
g += (x >= 500);
x %= 500;
pair<int, int> ndp(dp[cur][j].first + g,
dp[cur][j].second + P[i]);
update(dp[nxt][j-500+x], ndp);
}
if(j < 500) {
int x = j - p, g = 0;
if(x < 0) x += 1000;
g += (x >= 500);
x %= 500;
pair<int, int> ndp(dp[cur][j].first + g,
dp[cur][j].second + P[i]);
update(dp[nxt][x], ndp);
}
}
dp[cur][j] = NIL;
}
}
pair<int, int> ans = NIL;
for(int i=0; i<MAXP; i++) {
update(ans, dp[N%2][i]);
}
printf("%d %d\n", ans.first, ans.second);
return 0;
}
int main() {
while(!solve_testcase());
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(int argc, char *argv[])
{
const int BIG = 1000000;
const int CMAX = 25000;
for(;;) {
int n;
cin >> n;
if(n == 0) break;
vector<int> ps;
for(int i = 0; i < n; i++) {
int p; cin >> p; ps.push_back(p);
}
// shop : at most 100
// change : at most 49900... too much?
// # of 500 got so far : at most 100
// value : minimum payment
vector<vector<int>> dp(CMAX+1, vector<int>(101, BIG));
vector<vector<int>> dpnew(CMAX+1, vector<int>(101, BIG));
dpnew[0][0] = 0;
int cmax = 0;
int kmax = 0;
for(int i = 0; i < n; i++) {
int kmax2 = kmax;
const int ii = i + 1;
// not buying
for(int j = 0; j <= cmax; j++) {
for(int k = max(0, kmax - (n-i)); k <= i; k++) {
dp[j][k] = dpnew[j][k];
}
}
// buying
for(int j = 0; j <= cmax; j++) {
const int p = ps[i] % 1000;
if(p != 0 && p <= 500) { // got 500!
const int jj = min(j + 500 - p, CMAX);
cmax = min(max(cmax, jj), CMAX);
for(int k = max(0, kmax - (n-i)); k <= kmax; k++) {
const int kk = k + 1;
if(dpnew[jj][kk] > dp[j][k] + ps[i]) {
dpnew[jj][kk] = dp[j][k] + ps[i];
kmax2 = max(kmax2, kk);
}
}
} else {
// get 500 if possible!
const int q = (p == 0 ? 1000 : p) - 500;
if(j >= q) {
const int jj = j - q;
for(int k = max(0, kmax - (n-i)); k <= kmax; k++) {
const int kk = k + 1;
if(dpnew[jj][kk] > dp[j][k] + ps[i]) {
dpnew[jj][kk] = dp[j][k] + ps[i];
kmax2 = max(kmax2, kk);
}
}
} else { // get change
const int jj = j + 1000 - p;
cmax = min(max(cmax, jj), CMAX);
if( jj < 1000) {
for(int k = max(0, kmax - (n-i)); k <= kmax; k++) {
const int kk = k;
if(dpnew[jj][kk] > dp[j][k] + ps[i]) {
dpnew[jj][kk] = dp[j][k] + ps[i];
kmax2 = max(kmax2, kk);
}
}
}
}
}
}
kmax = kmax2;
}
for(int k = 100; k >= 0; k--) {
int p = BIG;
for(int j = 0; j <= cmax; j++) {
p = min(p, dpnew[j][k]);
}
if(p != BIG) {
cout << k << " " << p << endl;
break;
}
}
}
return 0;
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct Info{
Info(int arg_num_500,int arg_kozeni){
num_500 = arg_num_500;
kozeni = arg_kozeni;
}
int num_500,kozeni;
};
int N,max_kozeni[101],max_500,next_max_500,next_max_kozeni[101];
int** dp;
int** next_dp;
void func(){
int P;
max_500 = 0;
for(int i = 0; i <= N; i++){
max_kozeni[i] = 0;
}
for(int i = 0; i <= N; i++){
for(int k = 0; k <= 500*N;k++){
dp[i][k] = BIG_NUM;
next_dp[i][k] = BIG_NUM;
}
}
vector<Info> Updated;
dp[0][0] = 0;
next_dp[0][0] = 0;
for(int loop = 0; loop < N; loop++){
scanf("%d",&P);
next_max_500 = max_500;
for(int i = 0;i <= N; i++){
next_max_kozeni[i] = max_kozeni[i];
}
for(int num_500 = 0; num_500 <= max_500; num_500++){
for(int kozeni = 0; kozeni <= max_kozeni[num_500]; kozeni++){
if(dp[num_500][kozeni] == BIG_NUM)continue;
if(P%1000 == 0){
if(kozeni >= 500){
next_max_500 = max(next_max_500,num_500+1);
int next_kozeni = kozeni-500;
if(next_dp[num_500+1][next_kozeni] > dp[num_500][kozeni]+P){
next_dp[num_500+1][next_kozeni] = dp[num_500][kozeni]+P;
Updated.push_back(Info(num_500+1,next_kozeni));
next_max_kozeni[num_500+1] = max(next_max_kozeni[num_500+1],next_kozeni);
}
}
}else{
int otsuri = 1000*((P/1000)+1)-P;
if(otsuri >= 500){
next_max_500 = max(next_max_500,num_500+1);
int next_kozeni = (otsuri-500)+kozeni;
if(next_dp[num_500+1][next_kozeni] > dp[num_500][kozeni]+P){
next_dp[num_500+1][next_kozeni] = dp[num_500][kozeni]+P;
Updated.push_back(Info(num_500+1,next_kozeni));
next_max_kozeni[num_500+1] = max(next_max_kozeni[num_500+1],next_kozeni);
}
}else{
if(next_dp[num_500][kozeni+otsuri] > dp[num_500][kozeni]+P){
next_dp[num_500][kozeni+otsuri] = dp[num_500][kozeni]+P;
Updated.push_back(Info(num_500,kozeni+otsuri));
next_max_kozeni[num_500] = max(next_max_kozeni[num_500],kozeni+otsuri);
}
if(otsuri+kozeni >= 500){
next_max_500 = max(next_max_500,num_500+1);
int next_kozeni = otsuri+kozeni-500;
if(next_dp[num_500+1][next_kozeni] > dp[num_500][kozeni]+P){
next_dp[num_500+1][next_kozeni] = dp[num_500][kozeni]+P;
Updated.push_back(Info(num_500+1,next_kozeni));
next_max_kozeni[num_500+1] = max(next_max_kozeni[num_500+1],next_kozeni);
}
}
}
}
}
}
for(int i = 0; i < Updated.size(); i++){
dp[Updated[i].num_500][Updated[i].kozeni] = next_dp[Updated[i].num_500][Updated[i].kozeni];
}
Updated.clear();
for(int i = 0; i <= N; i++){
max_kozeni[i] = next_max_kozeni[i];
}
max_500 = next_max_500;
}
int minimum = BIG_NUM;
for(int i = 0; i <= max_kozeni[max_500]; i++){
minimum = min(minimum,dp[max_500][i]);
}
printf("%d %d\n",max_500,minimum);
}
int main(){
dp = new int*[101];
next_dp = new int*[101];
for(int i = 0; i <= 100; i++){
dp[i] = new int[50001];
next_dp[i] = new int[50001];
}
while(true){
scanf("%d",&N);
if(N == 0)break;
func();
}
return 0;
} |
#include<iostream>
#include<vector>
using namespace std;
int main(int argc, char *argv[])
{
const int BIG = 1000000;
const int CMAX = 20000;
for(;;) {
int n;
cin >> n;
if(n == 0) break;
vector<int> ps;
for(int i = 0; i < n; i++) {
int p; cin >> p; ps.push_back(p);
}
// shop : at most 100
// change : at most 49900... too much?
// # of 500 got so far : at most 100
// value : minimum payment
vector<vector<int>> dp(CMAX+1, vector<int>(101, BIG));
vector<vector<int>> dpnew(CMAX+1, vector<int>(101, BIG));
dpnew[0][0] = 0;
int cmax = 0;
for(int i = 0; i < n; i++) {
const int ii = i + 1;
for(int j = 0; j <= cmax; j++) { // not buying
for(int k = 0; k <= i; k++) {
dp[j][k] = dpnew[j][k];
}
}
// buying
const int p = ps[i] % 1000;
if(p != 0 && p <= 500) { // got 500!
for(int j = 0; j <= cmax; j++) {
const int jj = min(j + 500 - p, CMAX);
cmax = min(max(cmax, jj), CMAX);
for(int k = 0; k <= i; k++) {
const int kk = k + 1;
dpnew[jj][kk] = min(dpnew[jj][kk], dp[j][k] + ps[i]);
}
}
} else {
// get 500 if possible!
const int q = (p == 0 ? 1000 : p) - 500;
for(int j = 0; j <= cmax; j++) {
if(j >= q) {
const int jj = j - q;
for(int k = 0; k <= i; k++) {
const int kk = k + 1;
dpnew[jj][kk] = min(dpnew[jj][kk], dp[j][k] + ps[i]);
}
} else { // get change
const int jj = j + 1000 - p;
cmax = min(max(cmax, jj), CMAX);
if( jj < 1000) {
for(int k = 0; k <= i; k++) {
const int kk = k;
dpnew[jj][kk] = min(dpnew[jj][kk], dp[j][k] + ps[i]);
}
}
}
}
}
}
for(int k = 100; k >= 0; k--) {
int p = BIG;
for(int j = 0; j <= cmax; j++) {
p = min(p, dpnew[j][k]);
}
if(p != BIG) {
cout << k << " " << p << endl;
break;
}
}
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <cmath>
using namespace std;
typedef pair<int, int>P;
int main(){
for(int n; cin>>n,n;){
int mx = 0;
vector<int>p(n);
for(int i=0;i<n;i++){
cin>>p[i];
}
map<P, int>dp[2];
dp[0][P(0, 0)] = 0;
for(int i=0;i<n;i++){
map<P, int>::iterator it = dp[i%2].begin();
for(;it!=dp[i%2].end();it++){
int earn = (*it).first.first;
int satsu = (*it).first.second;
int pay = (*it).second;
int zeni = satsu * 1000 - pay - earn * 500;
//pass
if(dp[(i+1)%2].find(P(earn, satsu)) == dp[(i+1)%2].end()){
dp[(i+1)%2][P(earn, satsu)] = pay;
}
else{
dp[(i+1)%2][P(earn, satsu)] = min(dp[(i+1)%2][P(earn, satsu)], pay);
}
//1000円だけで払う
int turi = 1000 - p[i] % 1000, get500 = 0;
if(turi == 1000)turi = 0;
if(turi >= 500){
turi -= 500;
get500 = 1;
}
int nxtEarn = earn + get500;
int nxtPay = pay + p[i];
int nxtSatsu = satsu + p[i] / 1000 + (p[i] % 1000 == 0?0:1);
if(dp[(i+1)%2].find(P(nxtEarn, nxtSatsu)) == dp[(i+1)%2].end()){
dp[(i+1)%2][P(nxtEarn, nxtSatsu)] = nxtPay;
}
else{
dp[(i+1)%2][P(nxtEarn, nxtSatsu)] = min(dp[(i+1)%2][P(nxtEarn, nxtSatsu)], nxtPay);
}
//500円もらえるように払う
int need = abs((p[i] % 1000) - 500);
if(zeni < need)continue;
nxtEarn = earn + 1;
nxtPay = pay + p[i];
if(dp[(i+1)%2].find(P(nxtEarn, nxtSatsu)) == dp[(i+1)%2].end()){
dp[(i+1)%2][P(nxtEarn, nxtSatsu)] = nxtPay;
}
else{
dp[(i+1)%2][P(nxtEarn, nxtSatsu)] = min(dp[(i+1)%2][P(nxtEarn, nxtSatsu)], nxtPay);
}
}
dp[i%2].clear();
}
int c = 0, s = 0;
for(map<P, int>::iterator it = dp[n%2].begin(); it != dp[n%2].end(); it++){
int earn = (*it).first.first;
int satsu = (*it).first.second;
int pay = (*it).second;
int zeni = satsu * 1000 - pay - earn * 500;
if(earn > c){
c = earn;
s = pay;
}
else if(earn == c && pay < s){
c = earn;
s = pay;
}
}
cout<<c<<" "<<s<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int dp[128][128][1024];
int n;
int P[128];
void init() {
for(int i = 0; i < 128; ++i) {
for(int j = 0; j < 128; ++j) {
for(int k = 0; k < 1024; ++k) {
dp[i][j][k] = -1;
}
}
}
}
int main() {
for(;;) {
init();
scanf("%d", &n);
if( n == 0 ) break;
for(int i = 0; i < n; ++i) {
scanf("%d", &P[i]);
}
dp[0][0][0] = 0;
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
for(int k = 0; k < 1024; ++k) {
if( dp[i][j][k] == -1 ) continue;
// step 1
dp[i+1][j][k] = std::max(dp[i+1][j][k], dp[i][j][k]);
// step 2
int count_1000 = (P[i] + 999) / 1000;
int rem = dp[i][j][k] + count_1000 * 1000 - P[i];
int& next = dp[i+1][j + (rem>=500 ? 1 : 0)][k + count_1000];
next = std::max(next, rem>=500 ? rem - 500 : rem);
}
}
}
for(int i = 0; i < 6; ++i) {
for(int j = 0; j < 6; ++j) {
for(int k = 0; k < 6; ++k) {
//printf("(i, j, k) = (%d, %d, %d) : %d\n", i, j, k, dp[i][j][k]);
}
}
}
int res = (1 << 28);
int max = -1;
for(int j = n; j >= 0; --j) {
for(int k = 0; k < 1024; ++k) {
if( dp[n][j][k] == -1 ) continue;
int cost = k * 1000 - 500 * j - dp[n][j][k];
res = std::min(res, cost);
}
if( res != (1 << 28) ) {
max = j;
break;
}
}
printf("%d %d\n", max, res);
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define M 25000
int dp[2][101][M];
int main(){
int n;
while(cin>>n,n){
int p[100],pp[100];
for(int i=0;i<n;i++)scanf("%d",&p[i]),pp[i]=(1000-p[i]%1000)%1000;
for(int i=0;i<2;i++)
for(int j=0;j<=n;j++)
for(int k=0;k<M;k++)dp[i][j][k]=1e9;
dp[0][0][0]=0;
for(int i=0;i<n;i++){
int ni=(i+1)%2,I=i%2,mm=min(M,500*i+1);
for(int j=0;j<=i;j++)
for(int k=0;k<mm;k++)dp[ni][j][k]=1e9;
for(int j=0;j<=i;j++)
for(int k=0;k<mm;k++){
int np=k+pp[i];
int nj=j;
if(np>=500)nj++,np-=500;
np=min(M-1,np);
dp[ni][nj][np]=min(dp[ni][nj][np],dp[I][j][k]+p[i]);
dp[ni][j][k]=min(dp[ni][j][k],dp[I][j][k]);
}
}
int c=0,s=0;
for(int i=1;i<=n;i++)
for(int j=0;j<M;j++)
if(dp[n%2][i][j]!=1e9&&i>=c){
if(c==i&&dp[n%2][i][j]<s)s=dp[n%2][i][j];
else if(c<i)c=i,s=dp[n%2][i][j];
}
printf("%d %d\n",c,s);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<int,int> pint;
int p[101];
pint dp[101][60001];
int INF=1000100010;
int main(){
int n;
while(cin>>n,n){
rep(i,n) cin>>p[i];
FOR(i,0,n+1)rep(j,50001) dp[i][j]={0,-INF};
dp[0][0]={0,0};
rep(i,n){
int cp=p[i];
rep(j,50001){
if(dp[i][j]==pint(0,-INF)) continue;
dp[i+1][j]=max(dp[i+1][j],dp[i][j]);
if(p[i]%1000==0){
if(j<500) continue;
else{
pint tmp=dp[i][j];
tmp.second-=cp;++tmp.first;
dp[i+1][j-500]=max(dp[i+1][j-500],tmp);
}
continue;
}
if(cp%1000>500){
if(cp%1000-500<=j){
pint tmp=dp[i][j];
tmp.second-=cp;
dp[i+1][j+1000-cp%1000]=max(dp[i+1][j+1000-cp%1000],tmp);
++tmp.first;
dp[i+1][j-cp%1000+500]=max(dp[i+1][j-cp%1000+500],tmp);
}
else{
pint tmp=dp[i][j];
tmp.second-=cp;
dp[i+1][j+1000-cp%1000]=max(dp[i+1][j+1000-cp%1000],tmp);
}
}
else{
pint tmp=dp[i][j];
tmp.second-=cp;++tmp.first;
dp[i+1][j+1000-cp%1000-500]=max(dp[i+1][j+1000-cp%1000-500],tmp);
}
}
}
pint mx={0,-INF};
rep(i,n+1)rep(j,50001) mx=max(mx,dp[i][j]);
cout<<mx.first<<" "<<-mx.second<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
//#define int long long
#define reps(i,s,n) for(int (i)=(s);(i)<(n);++(i))
#define rep(i,n) reps(i,0,n)
#define rept(i,n) rep(i,(n)+1)
#define repst(i,s,n) reps(i,s,(n)+1)
#define reprt(i,n,t) for(int (i)=(n);(i)>=(t);--(i))
#define repr(i,n) reprt(i,n,0)
#define each(itr,v) for(auto &(itr):(v))
#define all(c) (c).begin(),(c).end()
#define rall(c) (c).rbegin(),(c).rend()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define tmax(x,y,z) max(x,max(y,z))
#define tmin(x,y,z) min(x,min(y,z))
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
#define ln '\n'
#define bln(i,n) (((i)==(n)-1)?'\n':' ')
#define dbg(x) cout<<#x" = "<<(x)<<ln<<flush
#define dbga(x,n) {cout<<#x" : ";for(int (i)=0;i<(n);++i){cout<<((x)[i])<<(i==((n)-1)?'\n':' ')<<flush;}}
#define zero(a) memset(a,0,sizeof(a))
#define unq(a) sort(all(a)),a.erase(unique(all(a)),a.end())
typedef long double ld;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<string> vst;
typedef vector<bool> vb;
typedef vector<ld> vld;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<vector<int> > mat;
const ll inf = (ll)1e9+10;
const ll linf = (ll)1e18+10;
const ll mod = (ll)(1e9+7);
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const int ddx[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[] = {1, 1, 0, -1, -1, -1, 0, 1};
const double eps = 1e-10;
ll mop(ll a,ll b,ll m=mod) {ll r=1;a%=m;for(;b;b>>=1){if(b&1)r=r*a%m;a=a*a%m;}return r;}
ll gcd(ll a,ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b) {return a*b/gcd(a,b);}
bool ool(int x,int y,int h,int w) {return((x<0)||(h<=x)||(y<0)||(w<=y));}
struct oreno_initializer {
oreno_initializer() {
cin.tie(0);
ios::sync_with_stdio(0);
}
} oreno_initializer;
// ━━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…
// .｡.:( ^ω^)・ﾟ＋.｡.:( ^ω^)・ﾟ＋.｡.:( ^ω^)・ﾟ＋.｡.:( ^ω^)・ﾟ＋.｡.:( ^ω^)・ﾟ＋
// ・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・‥…━━━☆・
// dp[i][j]: i番目の店までで100円以下の小銭の総額がjとなるような買い方の{500円玉の枚数,-購入金額}の最大値
// 遷移は a)500円玉を得られるように買う b)1000円札のみで買って小銭を稼ぐ c)買わない
// bでも500円玉を得られる場合がある
int n, p[100];
pii dp[101][50050];
signed main() {
while (1) {
cin >> n;
if (n==0) break;
rep(i,n) cin >> p[i];
rept(i,n) rept(j,50000) dp[i][j] = {-1,0};
dp[0][0] = {0,0};
rep(i,n) rept(j,50000) if (dp[i][j].fi!=-1) {
int g = dp[i][j].fi, u = -dp[i][j].se;
// 500円玉を得る
if (j>=(p[i]+500)%1000) chmax(dp[i+1][j-(p[i]+500)%1000], mp(g+1, -(u+p[i])));
// 1000円札のみ
if (1<=p[i]%1000 && p[i]%1000<=500) chmax(dp[i+1][j+(500-p[i]%1000)], mp(g+1, -(u+p[i])));
if (500<p[i]%1000) chmax(dp[i+1][j+(1000-p[i]%1000)], mp(g, -(u+p[i])));
// 買わない
chmax(dp[i+1][j], mp(g, -u));
}
pii res = mp(0,0);
rept(i,50000) chmax(res, dp[n][i]);
cout << res.fi << ' ' << -res.se << ln;
}
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int n,p;
pair<int,int> dp[101][50001];
int main() {
while (cin>>n && n != 0) {
memset(dp,-1,sizeof(dp));
dp[0][0] = pair<int,int>(0,0);
for (int i = 0; i < n; i++) {
cin>>p;
for (int t = 0; t < 500*n; t++) {
if (dp[i][t] == pair<int,int>(-1,-1)) continue;
dp[i+1][t] = max(dp[i][t],dp[i+1][t]);
if (p%1000<500 && p%1000) dp[i+1][t+(500-p%500)] = max(dp[i+1][t+(500-p%500)], pair<int,int>(dp[i][t].first+1,dp[i][t].second-p));
if (p%1000==0 && t>=500) dp[i+1][t-500] = max(dp[i+1][t-500],pair<int,int>(dp[i][t].first+1,dp[i][t].second-p));
if (p%1000>=500) {
if (t>=p%500) dp[i+1][t-p%500] = max(dp[i+1][t-p%500], pair<int,int>(dp[i][t].first+1,dp[i][t].second-p));
else dp[i+1][t+(500-p%500)] = max(dp[i+1][t+(500-p%500)], pair<int,int>(dp[i][t].first, dp[i][t].second-p));
}
}
}
pair<int,int> ans = pair<int,int>(0,0);
for (int i = 0; i < 50000; i++) ans = max(ans, dp[n][i]);
cout<<ans.first<<" "<<-ans.second<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
namespace {
typedef double real;
typedef long long ll;
template<class T> ostream& operator<<(ostream& os, const vector<T>& vs) {
if (vs.empty()) return os << "[]";
os << "[" << vs[0];
for (int i = 1; i < vs.size(); i++) os << " " << vs[i];
return os << "]";
}
template<class T> istream& operator>>(istream& is, vector<T>& vs) {
for (auto it = vs.begin(); it != vs.end(); it++) is >> *it;
return is;
}
int N;
vector<int> P;
bool input() {
cin >> N;
if (N == 0) return false;
P.clear(); P.resize(N); cin >> P;
return true;
}
struct Pair : pair<int,int> {
Pair(int a, int b) : pair<int,int>(a, b) {}
};
const int INF = 1<<28;
bool operator<(const Pair& a, const Pair& b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
Pair max(const Pair& a, const Pair& b) {
return (b < a ? a : b);
}
const int MAX_R = 101 * 500 + 5;
void solve() {
vector<vector<Pair>> dp(N + 1, vector<Pair>(MAX_R, Pair(-INF, INF)));
dp[0][0] = Pair(0, 0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < MAX_R; j++) {
const auto& cur = dp[i][j];
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
int p = P[i] % 1000;
if (p == 0) {
if (j >= 500) {
auto& next = dp[i + 1][j - 500];
next = max(next, Pair(dp[i][j].first + 1, dp[i][j].second + P[i]));
}
} else if (p <= 500) {
int nrem = j + (1000 - p) % 500;
auto& next = dp[i + 1][nrem];
next = max(next, Pair(cur.first + 1, cur.second + P[i]));
} else {
int d = p % 500;
if (j >= d) {
auto& next = dp[i + 1][j - d];
next = max(next, Pair(cur.first + 1, cur.second + P[i]));
} else {
auto& next = dp[i + 1][j + 1000 - p];
next = max(next, Pair(cur.first, cur.second + P[i]));
}
}
}
}
auto ans = Pair(-INF, INF);
for (int i = 0; i < MAX_R; i++) {
ans = max(ans, dp[N][i]);
}
cout << ans.first << " " << ans.second << endl;
}
}
int main() {
while (input()) solve();
return 0;
} |
#include <iostream>
#define REP(i, a, n) for(int i = (a); i < (n); i++)
#define INF 10000000
using namespace std;
struct state {
int n, cost;
bool operator<(const state s) const {
if(n < s.n) return true;
if(n > s.n) return false;
return cost > s.cost;
}
};
int N, P[100];
state dp[2][50000];
state max_state(state a, state b) {
return a < b ? b : a;
}
int main(void) {
while(cin >> N, N) {
REP(i, 0, N) cin >> P[i];
int current = 0, next = 1;
state m = (state) { 0, INF };
REP(i, 0, 2) REP(j, 0, 50000) dp[i][j] = m;
dp[current][0].cost = 0;
REP(i, 0, N) {
REP(j, 0, 50000) dp[next][j] = dp[current][j];
REP(j, 0, 50000) {
int change = (1000 - P[i] % 1000) % 1000;
int n = dp[current][j].n;
int cost = dp[current][j].cost;
int nn, ncost, nj;
if(cost >= INF) continue;
if(change >= 500) {
nn = n + 1;
nj = j + change - 500;
} else if(change < 500) {
if(j >= (500 - change)) {
nn = n + 1;
nj = j - (500 - change);
} else {
nn = n;
nj = j + change;
}
}
ncost = cost + P[i];
dp[next][nj] = max_state(dp[next][nj], (state) { nn, ncost });
}
swap(current, next);
}
state ans = m;
REP(i, 0, 50000) ans = max_state(ans, dp[current][i]);
cout << ans.n << " " << ans.cost << endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define REP(i,n) for(long long i=0;i<n;i++)
#define REP1(i,n) for(long long i=1;i<=n;i++)
#define REP2D(i,j,h,w) for(long long i=0;i<h;i++) for(long long j=0;j<w;j++)
#define REP2D1(i,j,h,w) for(long long i=1;i<=h;i++) for(long long j=1;j<=w;j++)
#define PER(i,n) for(long long i=((n)-1);i>=0;i--)
#define PER1(i,n) for(long long i=(n);i>0;i--)
#define FOR(i,a,b) for(long long i=(a);i<(b);i++)
#define FORE(i,a,b) for(long long i=(a);i<=(b);i++)
#define ITE(arr) for(auto ite=(arr).begin();ite!=(arr).end();++ite)
#define ALL(a) (a.begin()),(a.end())
#define RAN(a) (a),(a+sizeof(a)/sizeof(a[0]))
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
#define YNPRT(b) cout<<((b)?"Yes":"No")<<endl
#define REV(arr) reverse(ALL(arr))
#define PRT(a) cout<<a<<endl;
#define PRTLST(arr,num) REP(_i,num) cout<<_i<<" - "<<arr[_i]<<endl;
#define PRTLST2(arr2,d1,d2) REP(_i,d1) REP(_j,d2) cout<<_i<<","<<_j<<" : "<<arr2[_i][_j]<<endl;
#define PRTLST2D(arr2,d1,d2) do{cout<<"L\t";REP(_i,d2) cout<<_i<<"\t"; cout<<endl; REP(_i,d1){cout<<_i<<"\t";REP(_j,d2){cout<<arr2[_i][_j]<<"\t";}cout<<endl;}}while(0);
#define MIN(target,v1) (target)=min(target,v1)
#define MAX(target,v1) (target)=max(target,v1)
#define P1 first
#define P2 second
#define PB push_back
#define UB upper_bound
#define LB lower_bound
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int INF_INT = 2147483647;
const ll INF_LL = 9223372036854775807LL;
const ull INF_ULL = 18446744073709551615Ull;
const ll P = 92540646808111039LL;
const int Move[4][2] = {-1,0,0,1,1,0,0,-1};
const int Move_[8][2] = {-1,0,-1,-1,0,1,1,1,1,0,1,-1,0,-1,-1,-1};
//---------------------
#define MAXN 101
#define INF (1<<20)
//---------------------
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p) {os<<"( "<<p.P1<<" , "<<p.P2<<" )";return os;}
template<typename T>
ostream& operator<<(ostream& os,const vector<T>& v) {ITE(v) os << (ite-v.begin()) << " : " << *ite <<endl;return os;}
bool Cmp(const pii& a, const pii& b){
return a.P1==b.P1 ? a.P2>b.P2 : a.P1<b.P1 ;
}
int n,p[MAXN];
pii dp[2][MAXN*499];
bool init(){
ZERO(p);
REP2D(i,j,2,MAXN*499) dp[i][j]=pii(0,INF);
cin>>n;
if(n==0) return false;
REP1(i,n) cin>>p[i];
//sort(p+1,p+n+1,mycmp);
return true;
}
void maxopr(pii& a, pii b){
if(Cmp(a,b)) a=b;
}
int main(){
while(init()){
dp[1][0]=pii(0,0); // not buy
int firstchange=(1000-(p[1]%1000))%1000;
maxopr(dp[1][firstchange%500],pii(firstchange/500,p[1])); // buy & 1000
for(int i=1;i<=n-1;i++){
int cur=i%2;
int next=1-cur;
REP(j,MAXN*499){
if(dp[cur][j].P2>=INF) continue;
pii curdp=dp[cur][j];
maxopr(dp[next][j],curdp); // not buy
int change=(1000-(p[i+1]%1000))%1000;
if(change>=500) {maxopr(dp[next][j+change-500],pii(curdp.P1+1,curdp.P2+p[i+1]));} // buy & 1000
else {
maxopr(dp[next][j+change],pii(curdp.P1,curdp.P2+p[i+1])); // buy & 1000
if(j>=500-change) maxopr(dp[next][j-(500-change)],pii(curdp.P1+1,curdp.P2+p[i+1])); // buy & change
}
}
}
pii ret=dp[n%2][0];
REP(j,MAXN*499) {if(dp[n%2][j].P2>=INF) continue; maxopr(ret,dp[n%2][j]);}
cout<<ret.P1<<" "<<ret.P2<<endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
typedef long long ll;
const int INF = 100000000;
int dp[102][102][500];
int main()
{
while(true){
int n;
cin >> n;
if(n == 0) break;
int p[102];
int charge[102] {0};
for(int i = 1; i <= n; i++){
cin >> p[i];
charge[i] = charge[i - 1] + (6000 - p[i]) % 1000;
}
for(int i = 0; i <= n; i++){
for(int j = 0; j <= n; j++){
for(int k = 0; k < 500; k++){
dp[i][j][k] = INF;
}
}
}
for(int i = 0; i <= n; i++){
for(int k = 0; k < 500; k++){
dp[i][0][k] = 0;
}
}
for(int i = 1; i <= n; i++){
for(int j = 0; j <= n; j++){
for(int k = 0; k < 500; k++){
dp[i][j][k] = min(dp[i - 1][j][k] + p[i], INF);
if((6000 - p[i]) % 1000 <= k){
dp[i][j][k] = min(dp[i][j][k], dp[i - 1][j][k - (6000 - p[i]) % 1000]);
}
if(j > 0 && charge[i - 1] - k - (j - 1) * 500 + (6000 - p[i]) % 1000 >= 500){
dp[i][j][k] = min(dp[i][j][k], dp[i - 1][j - 1][k] + p[i]);
}
}
}
}
int j = 0;
for(; j <= n; j++){
if(dp[n][j][0] == INF) break;
}
int ans = INF;
for(int k = 0; k < 500; k++) ans = min(ans, dp[n][j - 1][k]);
cout << j - 1 << " " << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const ll MOD = 1000000007;
const int INF = 500002;
int p[102];
P dp[102][102][502];
bool visited[102][102][502];
int n;
P dfs(int pos, int r, int ex){
if(pos == n) return P(0, 0);
if(visited[pos][r][ex]) return dp[pos][r][ex];
int pay = 1000;
while(pay < p[pos]) pay += 1000;
int nex = ex + pay - p[pos];
int nr = r + nex / 500;
nex %= 500;
P ret = dfs(pos+1, r, ex);
if(nr > 0){
P res = dfs(pos+1, nr-1, nex);
ret = max(ret, P(res.first + 1, res.second - p[pos]));
}else{
P res = dfs(pos+1, nr, nex);
ret = max(ret, P(res.first, res.second - p[pos]));
}
dp[pos][r][ex] = ret;
visited[pos][r][ex] = true;
return ret;
}
int main(){
while(true){
cin >> n;
if(n == 0) break;
for(int i=0;i<n;i++){
cin >> p[i];
}
memset(visited, 0, sizeof(visited));
P ans = dfs(0, 0, 0);
cout << ans.first << " " << -ans.second << endl;
}
return 0;
} |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <string>
using ll = long long;
using namespace std;
#define MAX 50100
using P = pair<int, int>;
#define fi first
#define se second
#define amax(a, b) (a = (a < b ? b : a))
#define INF 1000000
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) break;
int p[n]; for (auto &pi:p) {
cin >> pi;
}
P dp[n+1][MAX];
fill(dp[0], dp[n+1], P{-INF, -INF});
dp[0][0] = P{0, 0};
for (int i=0; i<n; i++) {
for (int j=0; j<MAX; j++) {
amax(dp[i+1][j], dp[i][j]);
if (j >= (p[i] + 500) % 1000)
amax(dp[i+1][j - ((p[i] + 500) % 1000)], P(dp[i][j].fi + 1, dp[i][j].se - p[i]));
int change = 1000 - ((p[i] - 1) % 1000 + 1);
if (j + change % 500 <= MAX)
amax(dp[i+1][j + change % 500], P(dp[i][j].fi + change / 500, dp[i][j].se - p[i]));
// if (j % 100 == 0 && j < 1000)
// cerr << i << ' ' << j << ' ' << dp[i][j].fi << ' ' << dp[i][j].se << ' ' << (p[i] + 500) % 1000 << '\n';
}
}
P ans = {0, -INF};
for (auto &di:dp[n]) amax(ans, di);
cout << ans.fi << ' ' << -ans.se << '\n';
}
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <math.h>
#include <iostream>
#include <random>
#include<map>
#include <iomanip>
#include <time.h>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <cassert>
#include<fstream>
#include <unordered_map>
using namespace std;
#define Ma_PI 3.141592653589793
#define eps 0.00000000000000000000000001
#define LONG_INF 10000000000000000
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define REP(i,n) for(long long i = 0;i < n;++i)
pair<int, int> dp[2][99901];//左から1円,5円,10円,50円,100円
int main() {
while (true) {
int n;
scanf("%d", &n);
if (n == 0) return 0;
for (int i = 1; i < 99901; ++i) {
dp[0][i] = make_pair(-1000, 0);
dp[1][i] = make_pair(-1000, 0);
}
dp[0][0] = make_pair(0, 0);
dp[1][0] = make_pair(0, 0);
for (int i = 0; i < n; ++i) {
int now = 0;
scanf("%d", &now);
for (int j = 0; j < 99901; ++j) {
if (dp[i % 2][j].first >= 0) {
if (now % 1000 <= 500&&now % 1000 != 0) {
int ok = 0;
if (dp[(i + 1) % 2][j + 500 - now % 1000].first < dp[i % 2][j].first + 1) {
ok = 1;
}
if (dp[(i + 1) % 2][j + 500 - now % 1000].first == dp[i % 2][j].first+1 && dp[(i + 1) % 2][j + 500 - now % 1000].first > dp[i % 2][j].second + now) {
ok = 1;
}
if (ok == 1) {
dp[(i + 1) % 2][j + 500 - now % 1000] = make_pair(dp[i % 2][j].first + 1, dp[i % 2][j].second + now);
}
}
else {
//not taking
int ok = 0;
int itr = j + (1000 - now % 1000) % 1000;
if (dp[(i + 1) % 2][itr].first < dp[i % 2][j].first) {
ok = 1;
}
if (dp[(i + 1) % 2][itr].first == dp[i % 2][j].first && dp[(i + 1) % 2][itr].first > dp[i % 2][j].second + now) {
ok = 1;
}
if (ok == 1) {
dp[(i + 1) % 2][itr] = make_pair(dp[i % 2][j].first, dp[i % 2][j].second + now);
}
ok = 0;
itr = j;
if (dp[(i + 1) % 2][itr].first < dp[i % 2][j].first)ok = 1;
else if (dp[(i + 1) % 2][itr].first == dp[i % 2][j].first && dp[(i + 1) % 2][itr].second > dp[i % 2][j].second) ok = 1;
if (ok == 1) dp[(i + 1) % 2][itr] = dp[i % 2][j];
itr = j - (now % 1000 + 500) % 1000;
if (itr < 0) continue;
ok = 0;
if (dp[(i + 1) % 2][itr].first < dp[i % 2][j].first + 1) ok = 1;
if (dp[(i + 1) % 2][itr].first == dp[i % 2][j].first + 1 && dp[(i + 1) % 2][itr].second >= dp[i % 2][j].second + now) {
ok = 1;
}
if (ok == 1) {
dp[(i + 1) % 2][itr] = make_pair(dp[i % 2][j].first + 1, dp[i % 2][j].second + now);
}
}
}
}
}
pair<int, int> ans = make_pair(0, 0);
for (int i = 0; i < 99901; ++i) {
int ok = 0;
if (ans.first < dp[n % 2][i].first) {
ok = 1;
}
if (ans.first == dp[n % 2][i].first && ans.second > dp[n % 2][i].second) ok = 1;
if (ok == 1) {
ans = dp[n % 2][i];
}
}
cout << ans.first << " " << ans.second << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
int main(){
while(1){
int n;
cin >> n;
if (n == 0) break;
P ini = {0, 0};
vector<P> change(500 * n, ini);
vector<P> pre_change(500 * n, ini);
for (int i = 0; i < n; i++){
int p;
cin >> p;
if (p % 1000 == 0);
else if (pre_change[(1000 - p % 1000) % 500] == ini){
pre_change[(1000 - p % 1000) % 500].first = (p % 1000 > 0 && p % 1000 <= 500);
pre_change[(1000 - p % 1000) % 500].second = p;
}
else if (pre_change[(1000 - p % 1000) % 500].first < (p % 1000 > 0 && p % 1000 <= 500)){
pre_change[(1000 - p % 1000) % 500].first = (p % 1000 > 0 && p % 1000 <= 500);
pre_change[(1000 - p % 1000) % 500].second = p;
}
else if (pre_change[(1000 - p % 1000) % 500].first == (p % 1000 > 0 && p % 1000 <= 500) && pre_change[p].second > p){
pre_change[(1000 - p % 1000) % 500].second = p;
}
for (int j = 0; j < 500 * n; j++){
if (change[j] == ini) continue;
if (p % 1000 > 0 && p % 1000 <= 500){
if (pre_change[j + (1000 - p % 1000) % 500] == ini){
pre_change[j + (1000 - p % 1000) % 500].first = change[j].first + 1;
pre_change[j + (1000 - p % 1000) % 500].second = change[j].second + p;
}
else if (pre_change[j + (1000 - p % 1000) % 500].first < change[j].first + 1){
pre_change[j + (1000 - p % 1000) % 500].first = change[j].first + 1;
pre_change[j + (1000 - p % 1000) % 500].second = change[j].second + p;
}
else if (pre_change[j + (1000 - p % 1000) % 500].first == change[j].first + 1 && pre_change[j + (1000 - p % 1000) % 500].second > change[j].second + p){
pre_change[j + (1000 - p % 1000) % 500].second = change[j].second + p;
}
}
else if (p % 1000 > 0 && p % 1000 <= 500 + j){
if (pre_change[j - p % 500] == ini){
pre_change[j - p % 500].first = change[j].first + 1;
pre_change[j - p % 500].second = change[j].second + p;
}
else if (pre_change[j - p % 500].first < change[j].first + 1){
pre_change[j - p % 500].first = change[j].first + 1;
pre_change[j - p % 500].second = change[j].second + p;
}
else if (pre_change[j - p % 500].first == change[j].first + 1 && pre_change[j - p % 500].second > change[j].second + p){
pre_change[j - p % 500].second = change[j].second + p;
}
}
else if (p % 1000 == 0 && j >= 500){
if (pre_change[j - 500] == ini){
pre_change[j - 500].first = change[j].first + 1;
pre_change[j - 500].second = change[j].second + p;
}
else if (pre_change[j - 500].first < change[j].first + 1){
pre_change[j - 500].first = change[j].first + 1;
pre_change[j - 500].second = change[j].second + p;
}
else if (pre_change[j - 500].first == change[j].first + 1 && pre_change[j - 500].second > change[j].second + p){
pre_change[j - 500].second = change[j].second + p;
}
}
else if (p % 1000 != 0){
if (pre_change[j + (1000 - p % 1000)] == ini){
pre_change[j + (1000 - p % 1000)].first = change[j].first;
pre_change[j + (1000 - p % 1000)].second = change[j].second + p;
}
else if (pre_change[j + (1000 - p % 1000)].first < change[j].first){
pre_change[j + (1000 - p % 1000)].first = change[j].first;
pre_change[j + (1000 - p % 1000)].second = change[j].second + p;
}
else if (pre_change[j + (1000 - p % 1000)].first == change[j].first && pre_change[j + (1000 - p % 1000)].second > change[j].second + p){
pre_change[j + (1000 - p % 1000)].second = change[j].second + p;
}
}
}
change = pre_change;
}
int c = 0;
int s = 0;
for (int i = 0; i < 500 * n; i++){
if (change[i].first > c){
c = change[i].first;
s = change[i].second;
}
else if (change[i].first == c && change[i].second < s) s = change[i].second;
}
cout << c << " " << s << endl;
}
}
|
#include <bits/stdc++.h>
#define REP(i,n) for (int i=0;i<(n);i++)
#define FOR(i,s,e) for (int i=s;i<(e);i++)
#define All(v) (v).begin(),(v).end()
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define fi first
#define se second
#define int long long
using namespace std;
typedef long long llint;
typedef pair<int, int> P;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e18 * 5;
P dp[110][50010];
P max(P p1, P p2){
if(p1.fi > p2.fi) return p1;
if(p1.fi < p2.fi) return p2;
if(p1.se < p2.se) return p1;
if(p1.se > p2.se) return p2;
else return p1;
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
while(n != 0){
vector<int> p(n);
REP(i, n) cin >> p[i];
REP(i, n+1)REP(j, 50000) dp[i][j] = mp(-1, 0);
dp[0][0] = mp(0, 0);
REP(i, n){
int req = p[i]%1000;
if(req == 0) req = 1000;
REP(j, 50000){
if(dp[i][j].fi >= 0){
int c = req-500;
// 1000円払って 500円+小銭をGET
if(req <= 500) dp[i+1][j+(500-req)] = mp(dp[i][j].fi+1, dp[i][j].se+p[i]);
else{
// 1000+c円払って 500円を1枚GET
if(j >= c) dp[i+1][j-c] = max(dp[i+1][j-c], mp(dp[i][j].fi+1, dp[i][j].se+p[i]));
// 1000円払って 小銭をGET
dp[i+1][j+(1000-req)] = max(dp[i+1][j+(1000-req)], mp(dp[i][j].fi, dp[i][j].se+p[i]));
// 買わない
dp[i+1][j] = max(dp[i+1][j], dp[i][j]);
}
}
}
}
P ans = mp(0, 0);
REP(i, 50000){
ans = max(ans, dp[n][i]);
}
cout << ans.fi << " " << ans.se << "\n";
cin >> n;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
#include <cstring>
#include <utility>
#include <numeric>
using namespace std;
const int INF = 1e6;
int minCost[101][510][110]; // n, thousand, coin
int main(){
while(true){
int n;
cin >> n;
if(n == 0){
break;
}
vector<int> p(n);
for(int i = 0; i < n; i++){
cin >> p[i];
}
for(int i = 0; i <= n; i++){
for(int j = 0; j <= 500; j++){
for(int k = 0; k <= n; k++){
minCost[i][j][k] = INF;
}
}
}
minCost[0][0][0] = 0;
for(int i = 0; i < n; i++){
for(int j = 0; j < 500; j++){
for(int k = 0; k < n; k++){
int temp = minCost[i][j][k];
if(temp == INF){
continue;
}
minCost[i + 1][j][k] = min(minCost[i + 1][j][k], minCost[i][j][k]);
int nextJ;
int small = 1000 * j - temp - 500 * k;
int r = p[i] % 1000;
if(r != 0 && r <= 500){
nextJ = j + (p[i] / 1000) + 1;
minCost[i + 1][nextJ][k + 1] = min(minCost[i + 1][nextJ][k + 1], temp + p[i]);
}
else{
if(r == 0){
if(small >= 500){
nextJ = j + (p[i] / 1000);
minCost[i + 1][nextJ][k + 1] = min(minCost[i + 1][nextJ][k + 1], temp + p[i]);
}
}
else if(small >= r - 500){
nextJ = j + (p[i] / 1000) + 1;
minCost[i + 1][nextJ][k + 1] = min(minCost[i + 1][nextJ][k + 1], temp + p[i]);
}
}
nextJ = j + (int)ceil((double)p[i] / 1000);
minCost[i + 1][nextJ][k] = min(minCost[i + 1][nextJ][k], temp + p[i]);
}
}
}
int c, s;
c = 0;
s = 0;
for(int i = 0; i <= 500; i++){
for(int j = 0; j <= n; j++){
int temp = minCost[n][i][j];
if(temp == INF){
continue;
}
if(j > c){
c = j;
s = temp;
}
else if(j == c && temp < s){
s = temp;
}
}
}
cout << c << " " << s << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
constexpr int INF = 1e9;
int main() {
int n;
while(cin >> n, n) {
vector<int> p(n);
for(int i=0; i<n; ++i) {
cin >> p[i];
}
vector<vector<pii>> dp(n+1, vector<pii>(500*n, make_pair(INF, INF)));
dp[0][0] = make_pair(0, 0);
for(int i=0; i<n; ++i) {
for(int j=0; j<500*n; ++j) {
if(dp[i][j].first == INF) {
continue;
}
int noguti = ((p[i] + 999) / 1000) * 1000;
if(1 <= p[i] % 1000 && p[i] % 1000 <= 500) {
int coin = noguti - p[i] - 500;
pii next = make_pair(dp[i][j].first - 1, dp[i][j].second + p[i]);
dp[i+1][j+coin] = min(dp[i+1][j+coin], next);
} else {
dp[i+1][j] = min(dp[i+1][j], dp[i][j]); // not buy
int cost = ((p[i] % 1000) + 500) % 1000;
if(cost <= j) { // use coin
pii next = make_pair(dp[i][j].first - 1, dp[i][j].second + p[i]);
dp[i+1][j-cost] = min(dp[i+1][j-cost], next);
} else { // only noguti
pii next = make_pair(dp[i][j].first, dp[i][j].second + p[i]);
int coin = noguti - p[i];
dp[i+1][j+coin] = min(dp[i+1][j+coin], next);
}
}
}
}
auto res = *min_element(dp[n].begin(), dp[n].end());
cout << -res.first << ' ' << res.second << endl;
}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
using namespace std;
int n;
int d[110];
const int vmax=499*100+1;
int dp[110][vmax];
int dp2[110][vmax];
int main(void){
while(cin >> n,n){
rep(i,n) cin >> d[i];
rep(i,n+1)rep(j,vmax) dp[i][j]=-1,dp2[0][0]=0;
dp[0][0]=0;
rep(i,n)rep(j,vmax){
if(dp[i][j]==-1) continue;
if(dp[i+1][j]<dp[i][j]||(dp[i][j]==dp[i+1][j]&&dp2[i][j]<dp2[i+1][j])){
dp[i+1][j]=dp[i][j];
dp2[i+1][j]=dp2[i][j];
}
int next=dp[i][j];
int next2=dp2[i][j]+d[i];
int change=(5000-d[i])%1000;
int nj=j+change;
if(nj>=500) next++,nj-=500;
if(dp[i+1][nj]<next||(next==dp[i+1][nj]&&next2<dp2[i+1][nj])){
dp[i+1][nj]=next;
dp2[i+1][nj]=next2;
}
}
int ans=0,ans2=0;
rep(j,vmax){
if(ans<dp[n][j]||(dp[n][j]==ans&&dp2[n][j]<ans2)){
ans=dp[n][j];
ans2=dp2[n][j];
}
}
cout << ans << " " << ans2 << endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
#define MAX_N 100
#define MAX_C 100001
#define INF (1<<29)
typedef pair<int, int> pii;
int m[MAX_N];
pii dp[2][MAX_C];
void set_m(vector<int> &p)
{
for (int i = 0; i < (int)p.size(); i++) {
m[i] = ((p[i] - 1) / 1000 + 1) * 1000;
}
}
void update(pii &a, pii &b)
{
if (a.first < b.first) {
a = b;
} else if (a.first == b.first) {
if (a.second > b.second) {
a = b;
}
}
}
int main()
{
int N;
while (cin >> N, N) {
vector<int> p(N);
for (int i = 0; i < N; i++) {
cin >> p[i];
}
set_m(p);
memset(dp, -1, sizeof(dp));
for (int i = 0; i < 2; i++) {
for (int j = 0; j < MAX_C; j++) {
dp[i][j] = pii(-1, INF);
}
}
dp[0][0] = pii(0, 0);
for (int i = 0; i < N; i++) {
int curr = (i & 1), next = !(i & 1);
for (int j = 0; j < MAX_C; j++) {
if (dp[curr][j].first == -1) continue;
update(dp[next][j], dp[curr][j]);
{
int pay = m[i];
int change = pay - p[i];
int _500 = (change / 500);
int nc = j + change - _500 * 500;
pii ncost = pii(dp[curr][j].first + _500,
dp[curr][j].second + p[i]);
update(dp[next][nc], ncost);
}
{
int pp = p[i] % 1000;
if (pp > 500 || pp == 0) {
if (abs(pp - 500) <= j) {
int pay = m[i] + abs(pp - 500);
int change = pay - p[i];
int _500 = (change / 500);
int nc = j - abs(pp - 500) + change - _500 * 500;
pii ncost = pii(dp[curr][j].first + _500,
dp[curr][j].second + p[i]);
update(dp[next][nc], ncost);
}
}
}
}
for (int j = 0; j < MAX_C; j++) {
dp[curr][j] = pii(-1, INF);
}
}
pii res = pii(-1, INF);
for (int i = 0; i < MAX_C; i++) {
update(res, dp[N&1][i]);
}
cout << res.first << " " << res.second << endl;
}
return 0;
} |
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void chmax(int&a,int b)
{
a=max(a,b);
}
int main()
{
int n;
while(cin>>n,n)
{
vector<vector<int> >dp(n+2,vector<int>(5e2+1,-1));
dp[0][0]=0;
for(int count=0;count<n;count++)
{
int p;cin>>p;
int oturi=p%1000?1000-p%1000:0;
for(int k=n;k>=0;k--)
{
for(int j=5e2;j>=0;j--)
{
if(dp[k][j]<0)continue;
chmax(dp[k+(dp[k][j]+oturi>=500)][j+(p+999)/1000],
dp[k][j]+oturi-(dp[k][j]+oturi>=500?500:0));
}
}
}
int f=0;
for(int k=n;!f&&k>=0;k--)
{
for(int i=0;!f&&i<=5e2;i++)
{
if(dp[k][i]>=0)
{
cout<<k<<" "<<i*1000-dp[k][i]-k*500<<endl;
f=1;
}
}
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
pint INF(INT_MAX,INT_MAX);
pint dp[55555];
pint nex[55555];
int N;
int P[111];
void solve(){
rep(i,N)cin>>P[i];
fill_n(dp,55555,INF);
dp[0]=pint(0,0);
for(int i=0;i<N;i++){
fill_n(nex,55555,INF);
for(int j=0;j<50000;j++){
chmin(nex[j],dp[j]);
int p=P[i]%1000;
if(p==0){
pint w=dp[j];
w.fi--;w.se+=P[i];
if(j>=500)chmin(nex[j-500],w);
}
else if(p<=500){
pint w=dp[j];
w.fi--;
w.se+=P[i];
chmin(nex[j+500-p],w);
}
else{
pint w=dp[j];
w.se+=P[i];
chmin(nex[j+1000-p],w);
w.fi--;
if(j-(p-500)>=0)chmin(nex[j-(p-500)],w);
}
}
rep(j,55555)dp[j]=nex[j];
}
pint ans=INF;
rep(i,55555)chmin(ans,dp[i]);
cout<<-ans.fi<<" "<<ans.se<<endl;
}
signed main(){
while(cin>>N,N)solve();
return 0;
} |
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
const int INF = 5000*100*3;
const int max_x = 102;
const int max_y = 12000;
int dp[max_x+10][max_y+10];
void solve(int n){
// init
for(int j=0;j<max_x+10;j++) for(int k=0;k<max_y+10;k++) dp[j][k] = INF;
vector<int> p(n);
for(int i=0;i<n;i++) cin >> p[i];
dp[0][0] = 0;
for(int i=0;i<n;i++){
const int &pi = p[i];
for(int x=n;x>=0;x--){
for(int y=max_y;y>=0;y--){
if(pi%1000<=500){
if(pi%1000>0 && y-(500-pi%1000)>=0 && x-1>=0)
dp[x][y] = min(dp[x][y],dp[x-1][y-(500-pi%1000)]+pi);
if(y+(pi%1000+500)<=max_y && x-1>=0)
dp[x][y] = min(dp[x][y],dp[x-1][y+(pi%1000+500)]+pi);
}else{
if(y+(pi%1000-500) <= max_y && x-1>=0) dp[x][y] = min(dp[x][y], dp[x-1][y + (pi%1000-500)] + pi);
if(y-(1000-pi%1000)>=0) dp[x][y] = min(dp[x][y], dp[x][y-(1000-pi%1000)] + pi);
}
}
}
}
for(int i=100;i>=0;i--){
int mn = INF;
for(int j=0;j<=max_y;j++){
if(dp[i][j] < INF){
mn = min(mn,dp[i][j]);
}
}
if(mn != INF){
cout << i << " " << mn << endl;
return;
}
}
}
int main(){
while(1){
int n; cin >> n;
if(n==0) break;
solve(n);
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef pair<P,int> T;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define all(x) (x).begin(),(x).end()
#define sq(x) ((x)*(x))
#define rep(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
#define repn(i,a,n) for(int (i)=(a);(i)<(int)(n);(i)++)
#define EQ(a,b) (abs((a)-(b))<eps)
template<class T> void chmin(T& a,const T& b){if(a>b)a=b;}
template<class T> void chmax(T& a,const T& b){if(a<b)a=b;}
int n;
int p[105];
P dp[105][100000];
P dfs(int id,int ch){
if(id==n){
return P(0,0);
}
int rem = p[id]%1000;
if(dp[id][ch].fi!=-1)return dp[id][ch];
P res = dfs(id+1,ch);
if(rem==0){
if(ch>=500){
P tmp = dfs(id+1,ch-500);
tmp.fi++;
tmp.sec-=p[id];
res = max(res,tmp);
}
}else{
if(ch+500-rem>=0){
P tmp = dfs(id+1,ch+500-rem);
tmp.fi++;
tmp.sec -= p[id];
res = max(res,tmp);
}
P tmp = dfs(id+1,ch+1000-rem);
tmp.sec -= p[id];
res = max(res,tmp);
}
return dp[id][ch]=res;
}
bool solve(){
cin >> n;
if(n==0)return false;
for(int i=0;i<n;i++){
cin >> p[i];
}
for(int i=0;i<105;i++){
for(int j=0;j<100000;j++){
dp[i][j]=P(-1,-1);
}
}
P ans = dfs(0,0);
cout << ans.fi << ' ' << -ans.sec << endl;
return true;
}
int main(){
while(solve()){}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, st, n) for (int i = st; i < n; ++i)
using pii = pair<int, int>;
#define chmax(a, b) a = max(a, b)
//#define chmin(a, b) a = min(a, b)
#define chmin(a, b, c) a = min(a, b, c)
#define inf (int)(1e9+7)
#define mod (ll)(1e9+7)
#define eb emplace_back
/*
dp[i番目の店][お釣り] = {500円玉の数、払った金額}
500円玉の数 -> 大きくしたい
払った金額 -> 小さくしたい
そういう比較関数作る
1. i番目の店では買わない
chmin(dp[i + 1][j], dp[i][j], comp);
2. i番目の店で買う
2-1. 1000円の倍数払って500円もらえる
i番目の店の商品の金額piを1000で割った余りqi
1 <= qi <= 500
1000円の倍数払って500円もらえる
1001 -> 2000払う
このとき小銭払わなくていいことをいう
商品の値段250円とする
小銭120円持ってる
1120円払う
1120 - 250 = 870円帰ってくる
870 = 500 + 250 + 120
結局払った小銭返ってくる
2-2. 小銭払って500円もらえるか
pi = 750
小銭250円いる
*/
bool comp(pii a, pii b) {
if (a.first != b.first) return a.first > b.first;
return a.second < b.second;
}
pii dp[107][501 * 101];
//各お店500未満のお釣り
void out(int a, int b) {cout << dp[a][b].first << " " << dp[a][b].second << endl;}
int main() {
int n;
while (cin >> n && n) {
int pi[n]; rep(i, n) cin >> pi[i];
rep(i, 107) rep(j, 501 * 101) dp[i][j] = {-1, inf}; //-1 for ただ小銭もらうとき
dp[0][0] = {0, 0};
rep(i, n) {
rep(j, 501 * 101) {
if (dp[i][j].second == inf) continue;
//not buy
chmin(dp[i + 1][j], dp[i][j], comp);
//1000円の倍数払って500円もらえるか
int qi = pi[i] % 1000;
int df = dp[i][j].first;
int ds = dp[i][j].second;
pii tmp = {df + 1, ds + pi[i]};
if (1 <= qi && qi <= 500) chmin(dp[i + 1][j + (1000 - 500 - qi)], tmp, comp);
//小銭使って500円もらえるか
tmp = {df + 1, ds + pi[i]};
int need = (pi[i] + 500) % 1000;
if (need <= j) chmin(dp[i + 1][j - need], tmp, comp);
//ただ小銭もらう
tmp = {df, ds + pi[i]};
chmin(dp[i + 1][j + (1000 - pi[i]%1000) % 1000], tmp, comp);
}
}
pii ans = {0, inf};
rep(j, 501 * 101) {
chmin(ans, dp[n][j], comp);
}
cout << ans.first << " " << ans.second << endl;
}
}
/*
corner case
1
1000
*/
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb(s) push_back(s)
#define mp(a,b) make_pair(a,b)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define maxch(x,y) x=max(x,y)
#define minch(x,y) x=min(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt(x) bitset<32>(x).count()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<P, int> PPI;
typedef pair<ll, ll> PL;
typedef pair<P, ll> PPL;
#define INF INT_MAX/3
#define MAX_N 1000
int n;
int p[111];
int dp[101][50100];
int main(){
cin.sync_with_stdio(false);
while(1){
cin>>n;
if(n==0)break;
rep(i,n)cin>>p[i];
rep(j,101)rep(k,50100)dp[j][k]=INF;
dp[0][0]=0;
rep(i,n)for(int j=100;j>=0;j--)for(int k=50000;k>=0;k--){
if(dp[j][k]==INF)continue;
if(p[i]%1000>500&&k>=(p[i]%1000-500)){
minch(dp[j+1][k-(p[i]%1000-500)],dp[j][k]+p[i]);
}else if(p[i]%1000==0&&k>=500){
minch(dp[j+1][k-500],dp[j][k]+p[i]);
}
int rest=(1000000-p[i])%1000;
minch(dp[j+rest/500][rest%500+k],dp[j][k]+p[i]);
}
int resa=0,resb=INF;
rep(j,101)rep(k,50100){
if(dp[j][k]!=INF&&resa<j){
resa=j;
resb=dp[j][k];
}else if(resa==j)minch(resb,dp[j][k]);
}
printf("%d %d\n", resa,resb);
}
return 0;
} |
#include <bits/stdc++.h>
// dp[i][500yen][num_1000yen] := remain ([i] is deleted)
int dp[128][512];
int n;
int P[128];
void init() {
for(int j = 0; j < 128; ++j) {
for(int k = 0; k < 512; ++k) {
dp[j][k] = -1;
}
}
}
int main() {
for(;;) {
init();
scanf("%d", &n);
if( n == 0 ) break;
for(int i = 0; i < n; ++i) {
scanf("%d", &P[i]);
}
int k_max = 0;
dp[0][0] = 0;
for(int i = 0; i < n; ++i) {
k_max += (P[i] + 999) / 1000;
for(int j = i; j >= 0; --j) {
for(int k = k_max; k >= 0; --k) {
if( dp[j][k] == -1 ) continue;
int n1kyen = (P[i] + 999) / 1000;
int rem = dp[j][k] + n1kyen * 1000 - P[i];
int next_num500yen = j + (rem >= 500 ? 1 : 0);
int next_num1kyen = k + n1kyen;
int next_rem = rem >= 500 ? rem - 500 : rem;
int& next = dp[next_num500yen][next_num1kyen];
next = std::max(next, next_rem);
}
}
}
int res = (1 << 28);
int max = -1;
for(int j = n; j >= 0; --j) {
for(int k = 0; k < 512; ++k) {
if( dp[j][k] == -1 ) continue;
int cost = k * 1000 - 500 * j - dp[j][k];
res = std::min(res, cost);
}
if( res != (1 << 28) ) {
max = j;
break;
}
}
printf("%d %d\n", max, res);
}
return 0;
} |
#include <iostream>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
typedef pair<int, int> P;
void solve() {
int N;
cin >> N;
if (N == 0) exit(0);
vector<int> p(N);
REP(i, N) { cin >> p[i]; }
// dp[i][j]=i番目までで、おつりがj円の時の、{500円玉の枚数のmax,消費金額のmin}
vector<vector<P>> dp(N + 1, vector<P>(50500, {-1, 1e8}));
dp[0][0] = {0, 0};
REP(i, N) {
REP(j, 50005) {
if (dp[i][j].first == -1) continue;
int otsuri = (1000 - p[i] % 1000) % 1000;
int cnt = dp[i][j].first;
int cost = dp[i][j].second;
//買わない
if (cnt > dp[i + 1][j].first) {
dp[i + 1][j] = {cnt, cost};
} else if (cnt == dp[i + 1][j].first && cost < dp[i + 1][j].second) {
dp[i + 1][j] = {cnt, cost};
}
//おつりが500円以上の時(1000円で買えば500円がもらえる)
if (otsuri >= 500) {
// 500円のmaxを増やせるとき
if (cnt + 1 > dp[i + 1][j + otsuri - 500].first) {
dp[i + 1][j + otsuri - 500] = {cnt + 1, cost + p[i]};
}
//消費金額のminを小さくできるとき
else if (cnt + 1 == dp[i + 1][j + otsuri - 500].first &&
cost + p[i] < dp[i + 1][j + otsuri - 500].second) {
dp[i + 1][j + otsuri - 500] = {cnt + 1, cost + p[i]};
}
} else {
//手持ちのおつりと合わせて500円がもらえる
if (j + otsuri >= 500) {
int d = 500 - otsuri; // 500円との差額
//買うけど500円はもらわない
if (cnt > dp[i + 1][j + otsuri].first) {
dp[i + 1][j + otsuri] = {cnt, cost + p[i]};
} else if (cnt == dp[i + 1][j + otsuri].first && cost + p[i] < dp[i + 1][j + otsuri].second) {
dp[i + 1][j + otsuri] = {cnt, cost + p[i]};
}
// 500円のmaxを増やせるとき
if (cnt + 1 > dp[i + 1][j - d].first) {
dp[i + 1][j - d] = {cnt + 1, cost + p[i]};
}
//消費金額のminを小さくできるとき
else if (cnt + 1 == dp[i + 1][j - d].first && cost + p[i] < dp[i + 1][j - d].second) {
dp[i + 1][j - d] = {cnt + 1, cost + p[i]};
}
} else {
if (cnt > dp[i + 1][j + otsuri].first) {
dp[i + 1][j + otsuri] = {cnt, cost + p[i]};
} else if (cnt == dp[i + 1][j + otsuri].first && cost + p[i] < dp[i + 1][j + otsuri].second) {
dp[i + 1][j + otsuri] = {cnt, cost + p[i]};
}
}
}
}
}
int cnt_max = 0;
REP(j, 50001) { cnt_max = max(cnt_max, dp[N][j].first); }
int mn_cost = 1e9;
REP(j, 50001) {
if (dp[N][j].first == cnt_max) {
mn_cost = min(mn_cost, dp[N][j].second);
}
}
cout << cnt_max << " " << mn_cost << endl;
}
int main() {
while (true) solve();
}
|
#include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long LL;
typedef pair<int,int> P;
const LL mod=1e9+7;
const LL LINF=1LL<<62;
const LL INF=1<<17;
P dp[102][50501];
P pmax(P p,P q){
if(p.fs>q.fs) return p;
else if(p.fs==q.fs) return (p.sc<q.sc?p:q);
else return q;
}
int main(){
int N;
while(cin >> N){
if(!N) return 0;
int p[N];
for(int i=0;i<N;i++){
cin >> p[i];
}
for(int i=0;i<=N;i++){
for(int j=0;j<50001;j++){
if(j==0) dp[i][j]=mp(0,0);
else dp[i][j]=mp(-1,INF);
}
}
for(int i=0;i<N;i++){
for(int j=0;j<50001;j++){
if(dp[i][j].fs==-1){
continue;
}
P d=dp[i][j];
dp[i+1][j]=pmax(dp[i+1][j],d);
d.sc+=p[i];
int res=(1000-p[i]%1000)%1000;
dp[i+1][j+res]=pmax(dp[i+1][j+res],d);
if(res>=500){
d.fs++;
res-=500;
dp[i+1][j+res]=pmax(dp[i+1][j+res],d);
}
else{
d.fs++;
res=500-res;
if(res<=j) dp[i+1][j-res]=pmax(dp[i+1][j-res],d);
}
}
}
P ans=mp(0,LINF);
for(int i=0;i<=50000;i++){
ans=pmax(ans,dp[N][i]);
}
cout << ans.fs << " " << ans.sc << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-9;
//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
int main() {
while (1) {
int N; cin >> N;
if (!N)break;
vector<int>ps(N);
for (int i = 0; i < N; ++i) {
cin >> ps[i];
}
vector < vector<pair<int, int>>>dp(N + 1, vector<pair<int, int>>(50000,make_pair(-1000,0)));
dp[0][0] = make_pair(0, 0);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 49500; ++j) {
const int nc = dp[i][j].first;
const int nmoney = -dp[i][j].second;
dp[i + 1][j] = max(dp[i + 1][j], make_pair(nc, -nmoney));
const int price = ps[i];
const int amari = price % 1000;
if (amari == 0) {
int nextmoney = j;
int plusc = 0;
if (nextmoney >= 500) {
plusc++;
nextmoney -= 500;;
}
dp[i + 1][nextmoney] = max(dp[i + 1][nextmoney], make_pair(nc + plusc, -nmoney - price));
}else
if (amari <= 500) {
int nextmoney = j + 500 - amari;
int plusc = 1;
dp[i + 1][nextmoney] = max(dp[i + 1][nextmoney], make_pair(nc + plusc, -nmoney-price));
}
else {
int nextmoney =j + 1000 - amari;
int plusc = 0;
if (nextmoney >= 500) {
plusc++;
nextmoney -= 500;;
}
dp[i + 1][nextmoney] = max(dp[i + 1][nextmoney], make_pair(nc + plusc, -nmoney - price));
}
}
}
pair<int, int>ans = make_pair(0, 0);
for (int i = 0; i < 50000; ++i) {
ans = max(ans, dp[N][i]);
}
cout << ans.first << " " << -ans.second << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<int(n);++i)
#define updmax(dp,x) dp=(dp.first == 0 ? x : max(dp,x))
using P = pair<int,int>;
int main(void){
int n;
while(cin>>n, n){
vector<int> p(n);
rep(i,n) cin>>p[i];
map<int,P> cur; // cur[coin] = <get,pay>
rep(i,n){
map<int,P> nxt;
updmax(cur[0],P(0,0));
for(auto &itr : cur){
int coin = itr.first;
int k = itr.second.first;
int pay = itr.second.second;
updmax(nxt[coin], P(k,pay));
pay -= p[i];
coin += (1000-p[i]%1000)%1000;
if(coin >= 500){
updmax(nxt[coin-500], P(k+1, pay));
}else if(p[i]%1000){
updmax(nxt[coin], P(k,pay));
}
}
cur = move(nxt);
}
P res = {0,0};
for(auto itr : cur){
res = max(res,itr.second);
}
cout<<res.first<<" "<<-res.second<<endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<utility>
using namespace std;
ostream& operator<<(ostream &os, const pair<int,int> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
int main(int argc, char *argv[])
{
const int BIG = 1000000;
const int CMAX = 50000;
for(;;) {
int n;
cin >> n;
if(n == 0) break;
vector<int> ps;
for(int i = 0; i < n; i++) {
int p; cin >> p; ps.push_back(p);
}
// shop : at most 100
// change : at most 49900... too much? to get 50, max = 25000
// value : (# 500 yen so far, minimum payment)
vector<pair<int,int>> dp(CMAX+1, pair<int,int>(BIG, BIG));
vector<pair<int,int>> dpnew(CMAX+1, pair<int,int>(BIG, BIG));
dpnew[0] = make_pair(0, 0);
int cmax = 0;
for(int i = 0; i < n; i++) {
// not buying
for(int j = 0; j <= cmax; j++) {
dp[j] = dpnew[j];
}
// buying
for(int j = 0; j <= cmax; j++) {
if(dp[j].first > 0) continue;
const int p = ps[i] % 1000;
if(p != 0 && p <= 500) { // got 500!
const int jj = min(j + 500 - p, CMAX);
cmax = min(max(cmax, jj), CMAX);
pair<int,int> dd(dp[j].first - 1, dp[j].second + ps[i]);
if(dd < dpnew[jj]) {
dpnew[jj] = dd;
}
} else {
// get 500 if possible!
const int q = (p == 0 ? 1000 : p) - 500;
if(j >= q) {
const int jj = j - q;
pair<int,int> dd(dp[j].first - 1, dp[j].second + ps[i]);
if(dd < dpnew[jj]) {
dpnew[jj] = dd;
}
} else { // get change
const int jj = (j + 1000 - p) % 1000;
cmax = min(max(cmax, jj), CMAX);
if( jj <= CMAX) {
pair<int,int> dd(dp[j].first, dp[j].second + ps[i]);
if(dd < dpnew[jj]) {
dpnew[jj] = dd;
}
}
}
}
}
}
pair<int,int> dd(BIG, BIG);
for(int j = 0; j <= cmax; j++) {
if(dpnew[j] < dd) {
dd = dpnew[j];
}
}
cout << -dd.first << " " << dd.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define repr(i,n) for(int i=(int)(n-1);i>=0;i--)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb(s) push_back(s)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout << #x" = " << x << endl
#define print(x) cout << x << endl
#define maxch(x,y) x=max(x,y)
#define minch(x,y) x=min(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt(x) bitset<32>(x).count()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<P, int> PPI;
typedef pair<int, P> PIP;
typedef pair<ll, ll> PL;
typedef pair<P, ll> PPL;
typedef set<int> S;
#define INF INT_MAX/3
#define MAX_N 1000000001
P dp[2][100 * 499 + 1];
int main(){
cin.sync_with_stdio(false);
int n;
while(cin >> n, n) {
vector<int> p(n);
rep(i, n) cin >> p[i];
rep(i, n * 499 + 1) dp[0][i] = dp[1][i] = P(0, INF);
dp[0][0] = dp[1][0] = P(0, 0);
rep(i, n) {
rep(j, n * 499 + 1) dp[(i + 1) % 2][j] = dp[i % 2][j];
rep(j, n * 499 + 1) {
if (dp[i % 2][j].se != INF) {
int change = (5000 - p[i]) % 1000;
if (change >= 500) {
if (dp[i % 2][j + change - 500].fi < dp[i % 2][j].fi + 1) {
dp[(i + 1) % 2][j + change - 500].fi = dp[i % 2][j].fi + 1;
dp[(i + 1) % 2][j + change - 500].se = dp[i % 2][j].se + p[i];
} else if (dp[i % 2][j + change - 500].fi == dp[i % 2][j].fi + 1) {
if (dp[i % 2][j + change - 500].se > dp[i % 2][j].se + p[i]) {
dp[(i + 1) % 2][j + change - 500].se = dp[i % 2][j].se + p[i];
}
}
} else {
if (dp[i % 2][j + change].fi < dp[i % 2][j].fi) {
dp[(i + 1) % 2][j + change].fi = dp[i % 2][j].fi;
dp[(i + 1) % 2][j + change].se = dp[i % 2][j].se + p[i];
} else if (dp[i % 2][j + change].fi == dp[i % 2][j].fi) {
if (dp[i % 2][j + change].se > dp[i % 2][j].se + p[i]) {
dp[(i + 1) % 2][j + change].se = dp[i % 2][j].se + p[i];
}
}
if (j + change >= 500) {
if (dp[i % 2][j + change - 500].fi < dp[i % 2][j].fi + 1) {
dp[(i + 1) % 2][j + change - 500].fi = dp[i % 2][j].fi + 1;
dp[(i + 1) % 2][j + change - 500].se = dp[i % 2][j].se + p[i];
} else if (dp[i % 2][j + change - 500].fi == dp[i % 2][j].fi + 1) {
if (dp[i % 2][j + change - 500].se > dp[i % 2][j].se + p[i]) {
dp[(i + 1) % 2][j + change - 500].se = dp[i % 2][j].se + p[i];
}
}
}
}
}
}
}
P maxi = P(0, 0);
rep(i, n * 499 + 1) {
if (maxi.fi < dp[n % 2][i].fi) maxi = dp[n % 2][i];
else if (maxi.fi == dp[n % 2][i].fi && maxi.se > dp[n % 2][i].se) maxi = dp[n % 2][i];
}
cout << maxi.fi << " " << maxi.se << endl;
}
return 0;
} |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define reps(i,f,n) for(int i=f; i<n; ++i)
#define rep(i,n) reps(i,0,n)
#define maxl(a,b) a = max(a, b)
pair<int, int> dp[101][210 * 500];
const int MAX = 1001001001;
void solve(int n)
{
vector<int> p(n);
rep(i, n){
cin >> p[i];
}
rep(i, n+1){
rep(c, 210*500){
dp[i][c] = {-MAX, 0};
}
}
dp[0][0] = {0, 0};
rep(i, n){
rep(c, (n+10)*500){
auto r = dp[i][c];
maxl(dp[i+1][c], r);
int pr = p[i] % 1000;
if(pr == 0){
if(c >= 500) maxl(dp[i+1][c - 500], make_pair(r.first+1, r.second - p[i]));
}
else if(pr <= 500){
maxl(dp[i+1][c + 500 - pr], make_pair(r.first+1, r.second - p[i]));
}
else{
maxl(dp[i+1][c - pr + 1000], make_pair(r.first, r.second - p[i]));
if(c >= pr - 500) maxl(dp[i+1][c - pr + 500], make_pair(r.first+1, r.second - p[i]));
}
}
}
auto ans = *max_element(dp[n], dp[n] + 210*500);
cout << ans.first << ' ' << -ans.second << endl;
}
int main()
{
int n;
while(cin >> n, n){
solve(n);
}
} |
#include<bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
const int M = 1000000007;
int main() {
while (1) {
int n;
cin >> n;
if (!n) return 0;
int lim = n * 499 + 1;
vector<P> dp(lim, P(-M, -M));
dp[0] = P(0, 0);
for (int i = 0; i < n; ++i) {
int p;
cin >> p;
vector<P> nex = dp;
int q = (500 - p % 500) % 500;
if (p % 1000 > 0 && p % 1000 <= 500)
for (int j = q; j < lim; ++j)
nex[j] = max(nex[j], P(dp[j - q].first + 1, dp[j - q].second - p));
else {
int r = p % 500 == 0 ? 500 : p % 500;
for (int j = q; j < lim; ++j)
nex[j] = max(nex[j], P(dp[j - q].first, dp[j - q].second - p));
for (int j = 0; j + r < lim; ++j)
nex[j] = max(nex[j], P(dp[j + r].first + 1, dp[j + r].second - p));
}
dp = nex;
}
int ma = 0, mi = 0;
for (auto& a : dp) {
if (a.first > ma) {
ma = a.first;
mi = -a.second;
}
else if (a.first == ma && -a.second < mi)
mi = -a.second;
}
cout << ma << " " << mi << "\n";
}
}
|
#include <bits/stdc++.h>
int dp[128][128][1024];
int n;
int P[128];
void init() {
for(int i = 0; i < 128; ++i) {
for(int j = 0; j < 128; ++j) {
for(int k = 0; k < 1024; ++k) {
dp[i][j][k] = -1;
}
}
}
}
int main() {
for(;;) {
init();
scanf("%d", &n);
if( n == 0 ) break;
for(int i = 0; i < n; ++i) {
scanf("%d", &P[i]);
}
dp[0][0][0] = 0;
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
for(int k = 0; k < 1024; ++k) {
if( dp[i][j][k] == -1 ) continue;
dp[i+1][j][k] = std::max(dp[i+1][j][k], dp[i][j][k]);
// 1000
int count_1000_2 = (P[i] + 999) / 1000;
int rem0 = count_1000_2 * 1000 - P[i];
int& next0 = dp[i+1][j + (rem0%1000>=500 ? 1 : 0)][k + count_1000_2];
next0 = std::max(next0, dp[i][j][k] + (rem0%1000>=500 ? rem0 - 500 : rem0));
//
int count_1000 = (P[i] + 999) / 1000;
int rem1 = dp[i][j][k] + count_1000 * 1000 - P[i];
int& next = dp[i+1][j + (rem1>=500 ? 1 : 0)][k + count_1000];
next = std::max(next, rem1>=500 ? rem1 - 500 : rem1);
// //
// int rem11 = rem1 % 1000;
// int& next1 = dp[i+1][j + (rem11%1000>=500 ? 1 : 0)][k + count_1000];
// next1 = std::max(next1, rem11%1000>=500 ? rem11 - 500 : rem11);
// rem
if( dp[i][j][k] > P[i] ) {
int rem2 = dp[i][j][k] - P[i];
int& next = dp[i+1][j + (rem2%1000>=500 ? 1 : 0)][k];
next = std::max(next, (rem2%1000>=500 ? rem2 - 500 : rem2));
}
}
}
}
for(int i = 0; i < 6; ++i) {
for(int j = 0; j < 6; ++j) {
for(int k = 0; k < 6; ++k) {
//printf("(i, j, k) = (%d, %d, %d) : %d\n", i, j, k, dp[i][j][k]);
}
}
}
int res = (1 << 28);
int max = -1;
for(int j = n; j >= 0; --j) {
for(int k = 0; k < 1024; ++k) {
if( dp[n][j][k] == -1 ) continue;
int cost = k * 1000 - 500 * j - dp[n][j][k];
res = std::min(res, cost);
}
if( res != (1 << 28) ) {
max = j;
break;
}
}
printf("%d %d\n", max, res);
}
return 0;
} |
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <climits>
#include <cstring>
#include <cassert>
using namespace std;
#define SZ(x) (int)(x.size())
#define REP(i, n) for(int i=0;i<n;++i)
#define FOR(i, a, b) for(int i=a;i<b;++i)
#define RREP(i, n) for(int i=n-1;i>=0;--i)
#define RFOR(i, a, b) for(int i=b-1;i>=a;--i)
#define all(x) begin(x),end(x)
#define dump(x) cerr<<#x<<" = "<<(x)<<endl
#define debug(x) cerr<<#x<<" = "<<(x)<<" (L"<<__LINE__<<")"<< endl;
#pragma O3
//using ll = long long;
using ll = int;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<int, int>;
const double eps = 1e-8;
const ll MOD = 1000000007;
const int INF = INT_MAX / 2;
//const ll LINF = LLONG_MAX / 2;
template<class T>
inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> p) {
os << p.first << ":" << p.second;
return os;
}
template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
REP(i, SZ(v)) {
if (i) os << ", ";
os << v[i];
}
return os << "]";
}
// edit
ll dp[2][105][100001];
bool solve() {
// memset(dp, 0, sizeof(dp));
int N;
cin >> N;
if(N == 0) return false;
for(int j = 0; j <= N; ++j){
for(int k = 0; k <= 500 * N; ++k){
dp[0][j][k] = INF;
dp[1][j][k] = INF;
}
}
vector<int> p(N);
for(int i = 0; i < N; ++i){
cin >> p[i];
}
dp[0][0][0] = 0;
for(int i = 0; i < N; ++i){
// reset i + 1
int ci = i % 2;
int ni = (i + 1) % 2;
for(int j = 0; j <= N; ++j){
// for(int k = 0; k < 100001; ++k){
for(int k = 0; k <= 500 * i; ++k){
dp[ni][j][k] = INF;
}
}
for(int j = 0; j <= i; ++j){
// for(int k = 0; k < 100001; ++k){
for(int k = 0; k <= 500 * i; ++k){
if(dp[ci][j][k] == INF) continue;
// お金を使わない場合
chmin(dp[ni][j][k], dp[ci][j][k]);
// お金を使う場合
int turi = 1000 - p[i] % 1000;
if(turi == 1000) turi = 0;
if(k + turi >= 500){
chmin(dp[ni][j + 1][k + turi - 500], dp[ci][j][k] + p[i]);
}else{
chmin(dp[ni][j][k + turi], dp[ci][j][k] + p[i]);
}
}
}
}
ll max_val = 0, min_cost = 0;
for(int x = 0; x <= N; ++x){
// for(int y = 0; y < 100001; ++y){
for(int y = 0; y <= 500 * N; ++y){
if(dp[N % 2][x][y] < INF){
if(x > max_val){
max_val = x;
min_cost = dp[N%2][x][y];
}else if(x == max_val){
chmin(min_cost, dp[N%2][x][y]);
}
}
}
}
cout << max_val << " " << min_cost << endl;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
while( solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,k,n) for(int i = (int)(k); i < (int)(n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) a.begin(), a.end()
#define MS(m,v) memset(m,v,sizeof(m))
#define D10 fixed<<setprecision(10)
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-12;
template<class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template<class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
/*--------------------template--------------------*/
int n;
vi p;
pii dp[101][55555];
pii solve(int shop, int coin)
{
if (shop == n) return pii(0, 0);
if (dp[shop][coin].first >= 0) return dp[shop][coin];
pii res(0, 0);
chmax(res, solve(shop + 1, coin));
pii tmp;
if (p[shop] % 1000 == 0)
{
if (coin >= 500)
{
tmp = solve(shop + 1, coin - 500);
chmax(res, pii(tmp.first + 1, tmp.second - p[shop]));
}
}
else if (p[shop] % 1000 > 500)
{
tmp = solve(shop + 1, coin + 1000 - p[shop] % 1000);
chmax(res, pii(tmp.first, tmp.second - p[shop]));
if (p[shop] % 1000 - 500 <= coin)
{
tmp = solve(shop + 1, coin - (p[shop] % 1000 - 500));
chmax(res, pii(tmp.first + 1, tmp.second - p[shop]));
}
}
else
{
tmp = solve(shop + 1, coin + 500 - p[shop] % 1000);
chmax(res, pii(tmp.first + 1, tmp.second - p[shop]));
}
return dp[shop][coin] = res;
}
int main()
{
cin.sync_with_stdio(false);
while (cin >> n, n)
{
p.resize(n);
REP(i, n) cin >> p[i];
REP(i, 101)REP(j, 55555) dp[i][j] = pii(-1, -1);
pii ans = solve(0, 0);
cout << ans.first << " " << -ans.second << endl;
}
return 0;
} |
#include <cstdio>
#include <utility>
#include <algorithm>
using namespace std;
typedef pair<int,int> ans_t;
ans_t dp[105][50005];
int N;
int shops[105];
const ans_t& chmax(const ans_t& src,ans_t& target){
if (src.first>target.first||(src.first==target.first&&src.second<target.second))
return target=src;
else
return target;
}
int main(){
while(scanf("%d",&N)&&N){
for(int i=1;i<=N;i++) scanf("%d",shops+i);
for(int i=0;i<=N;i++)
for(int change=0;change<=50003;change++)
dp[i][change]=ans_t(-1,0);
dp[0][0]=ans_t(0,0);
ans_t ans(0,0);
for(int i=0;i<N;i++){
for(int change=0;change<=50000;change++){
const auto &cost=dp[i][change];
if (cost.first==-1) continue;
chmax(cost,dp[i+1][change]);
chmax(dp[i+1][change],ans);
auto cur_price=shops[i+1];
auto remain=(1000-cur_price%1000)%1000;
auto new_change=remain%500,new_500=remain/500;
chmax(ans_t(cost.first+new_500,cost.second+cur_price),
dp[i+1][min(change+new_change,50000)]);
chmax(dp[i+1][min(change+new_change,50000)],ans);
remain=(cur_price+500)%1000;
if (change>=remain){
chmax(ans_t(cost.first+1,cost.second+cur_price),
dp[i+1][change-remain]
);
chmax(dp[i+1][change-remain],ans);
}
}
// printf("%d %d\n",ans.first,ans.second);
}
printf("%d %d\n",ans.first,ans.second);
}
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0;i<(n);++i)
using namespace std;
constexpr int INF = 1000000000;
int main() {
while (true) {
int n;
cin>>n;
if(!n) break;
vector<int> p(n);
for(auto& v:p) cin>>v;
vector<vector<pair<int, int>>> dp(n+1,vector<pair<int, int>>(50000, make_pair(-INF, -INF)));
dp[0][0] = make_pair(0,0);
REP(i,n) {
REP(j,50000) {
dp[i+1][j] = max(dp[i+1][j], dp[i][j]);
int ex = (1000 - p[i] % 1000) % 1000;
if (ex < 500) {
if (j + ex < 50000) {
dp[i+1][j+ex] = max(dp[i+1][j+ex], make_pair(dp[i][j].first, dp[i][j].second - p[i]));
}
if (j + ex >= 500) {
dp[i+1][j+ex-500] = max(dp[i+1][j+ex-500], make_pair(dp[i][j].first+1, dp[i][j].second - p[i]));
}
} else {
dp[i+1][j+ex-500] = max(dp[i+1][j+ex-500], make_pair(dp[i][j].first+1, dp[i][j].second - p[i]));
}
}
}
pair<int, int> res(0, 0);
REP(i,50000) res = max(res, dp[n][i]);
cout << res.first << ' ' << -res.second << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAX = 5e2;
int main()
{
int n;
while (cin >> n, n) {
vector<int> p(n);
vector<vector<int>> dp(MAX + 1, vector<int>(101, -1));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
cin >> p[i];
for (int j = MAX; j >= 0; j--) {
for (int k = 100; k >= 0; k--) if (dp[j][k] != -1) {
int val = (p[i] + 999) / 1000;
if (p[i] % 1000 == 0 || p[i] % 1000 > 500) {
dp[j + val][k] = max(dp[j + val][k], dp[j][k] + val * 1000 - p[i]);
if (dp[j][k] >= (val * 1000 - p[i] - 500)) {
dp[j + val][k + 1] = max(dp[j + val][k + 1], dp[j][k] + val * 1000 - p[i] - 500);
}
}
else {
dp[j + val][k + 1] = max(dp[j + val][k + 1], dp[j][k] + val * 1000 - p[i] - 500);
}
}
}
}
int cnt = 0, res = 0;
for (int i = 0; i <= MAX; i++) {
for (int j = 0; j <= 100; j++) {
if (dp[i][j] != -1) {
if (cnt < j) {
cnt = j;
res = i * 1000 - 500 * j - dp[i][j];
}
else if (cnt == j) {
res = min(res, i * 1000 - 500 * j - dp[i][j]);
}
}
}
}
cout << cnt << ' ' << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}
typedef pair<int, int> Pi;
typedef tuple<int, int, int> Ti;
typedef vector<int> vint;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
Pi dp[2][100001];
signed main()
{
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
int n;
while(cin >> n, n) {
vint p(n);
rep(i, n) cin >> p[i];
fill(dp[0], dp[2], Pi(inf, inf));
Pi* curr = dp[0];
Pi* next = dp[1];
curr[0] = Pi(0, 0);
rep(i, n) {
rep(j, 100001) next[j] = Pi(inf, inf);
rep(j, 100001) {
chmin(next[j], curr[j]);
Pi d = curr[j];
int q = p[i]%1000;
int x = (1000-q)%1000;
if(j+x >= 500) { // ????????????500?????\???????????????????????°??????????????????????????????
if(j+x-500 <= 100000) {
d.first--;
d.second += p[i];
chmin(next[j+x-500], d);
}
} else {
if(j+x <= 100000) {
d.second += p[i];
chmin(next[j+x], d);
}
}
}
swap(curr, next);
}
Pi ans = Pi(inf, inf);
rep(i, 100001) chmin(ans, curr[i]);
cout << -ans.first << " " << ans.second << endl;
}
return 0;
} |
#include <iostream>
#include <algorithm>
#include <tuple>
using namespace std;
typedef pair<int,int> P; //500, -totalcost
P dp[101][50000];
int main(){
int n;
while(cin>>n,n){
fill(dp[0],dp[101],P(0,-5000000));
dp[0][0]=P(0,0);
for(int i=0;i<n;i++){
int price;
cin>>price;
for(int c=0;c<50000;c++){
if(dp[i][c].second<=-5000000) continue;
dp[i+1][c]=max(dp[i+1][c],dp[i][c]); //ティツイツキテ」ツつ湘」ツ?ェテ」ツ??
if(price%1000==0){
if(c>=500){
dp[i+1][c-500]=max(dp[i+1][c-500],P(dp[i][c].first+1,dp[i][c].second-price));
}
continue;
}else{
if(price%1000<=500){//500テ・ツ??ァツ篠嘉」ツ?ィテ」ツ?甘ゥツ?」テ」ツつ甘」ツ?古・ツ「ツ療」ツ?暗」ツつ?
int cc= c + 1000 - price%1000 - 500;
dp[i+1][cc]=max(dp[i+1][cc],P(dp[i][c].first+1,dp[i][c].second-price));
}else{
if(price%1000-500<=c){
int cc = c - (price%1000-500);
//テ・ツーツ湘ゥツ環ュテ」ツつ津ヲツクツ崚」ツつ嘉」ツ?療」ツ?ヲ500テ・ツ??ァツ篠嘉」ツつ津・ツ「ツ療」ツつ?」ツ??
dp[i+1][cc]=max(dp[i+1][cc],P(dp[i][c].first+1,dp[i][c].second-price));
}
//500テ・ツ??ァツ篠嘉」ツつ津・ツ「ツ療」ツつ?」ツ?陛」ツ?堙」ツ?ォテ・ツーツ湘ゥツ環ュテ」ツ??」ツ?妥・ツ「ツ療」ツつ?」ツ??
int cc = c + (1000-price%1000);
dp[i+1][cc]=max(dp[i+1][cc],P(dp[i][c].first,dp[i][c].second-price));
}
}
}
}
P ans = P(0,-5000000);
for(int c=0;c<50000;c++) if(dp[n][c].second>-5000000) ans = max(dp[n][c],ans);
cout<<ans.first<<' '<<-ans.second<<endl;
}
return 0;
} |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define LINF (ll)INF*INF
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<(n);i++)
#define loop(i,a,n) for(int i=a;i<(n);i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
typedef vector<pii> vp;
int gcd(int a, int b){
if(b==0) return a;
return gcd(b,a%b);
}
int lcm(int a, int b){
return a/gcd(a,b)*b;
}
int f(int a){
if(a%1000 == 0)return a;
a /= 1000;
a++;
return a*1000;
}
pii dp[105][105*1000];
//iまで見て小銭がj円のときの
//dp[i][j].first:500円玉の個数
//dp[i][j].second:最小金額
void update(pii &a,pii b){
if(b.second >= INF)return ;
if(a.first < b.first)a = b;
else if(a.first == b.first && a.second > b.second)a = b;
}
signed main(void) {
int n;
while(cin >> n,n){
vi p(n);
rep(i,n)cin >> p[i];
rep(i,n+1)rep(j,(n+1)*1000)dp[i][j] = pii(0,INF);
dp[0][0].second = 0;
rep(i,n)rep(j,(n+1)*1000){
int cnt = dp[i][j].first;
int sum = dp[i][j].second;
update(dp[i+1][j],dp[i][j]);//かわない
int t = f(p[i]) - p[i];//札のみのときのおつり
//if(sum < INF)cout << i << " " << j << " " << cnt << " " << sum << " " << t << endl;
if(t >= 500){
update(dp[i+1][j+t-500], pii(cnt+1,sum+p[i]));
}else{
update(dp[i+1][j+t], pii(cnt, sum+p[i]));
int ne = p[i]%500;//必要な端数
if(!ne)ne = 500;
if(ne <= j){//端数を消費し500円玉を手に入れる
update(dp[i+1][j-ne], pii(cnt+1,sum+p[i]));
}
}
}
pii ans = pii(0,INF);
rep(j,(n+1)*1000)update(ans,dp[n][j]);
cout << ans.first << " " << ans.second << endl;
}
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(int argc, char *argv[])
{
const int BIG = 1000000;
const int CMAX = 5000;
for(;;) {
int n;
cin >> n;
if(n == 0) break;
vector<int> ps;
for(int i = 0; i < n; i++) {
int p; cin >> p; ps.push_back(p);
}
// shop : at most 100
// change : at most 49900... too much?
// # of 500 got so far : at most 100
// value : minimum payment
vector<vector<vector<int>>> dp(n+1, vector<vector<int>>(CMAX+1, vector<int>(101, BIG)));
dp[0][0][0] = 0;
for(int i = 0; i < n; i++) {
const int ii = i + 1;
for(int j = 0; j <= CMAX; j++) { // not buying
for(int k = 0; k <= 100; k++) {
dp[ii][j][k] = dp[i][j][k];
}
}
// buying
const int p = ps[i] % 1000;
if(p != 0 && p <= 500) { // got 500!
for(int j = 0; j <= CMAX; j++) {
const int jj = min(j + 500 - p, CMAX);
for(int k = 0; k < 100; k++) {
const int kk = k + 1;
dp[ii][jj][kk] = min(dp[ii][jj][kk], dp[i][j][k] + ps[i]);
}
}
} else {
// get 500 if possible!
const int q = (p == 0 ? 1000 : p) - 500;
for(int j = 0; j <= CMAX; j++) {
if(j >= q) {
const int jj = j - q;
for(int k = 0; k < 100; k++) {
const int kk = k + 1;
dp[ii][jj][kk] = min(dp[ii][jj][kk], dp[i][j][k] + ps[i]);
}
} else { // get change
const int jj = j + 1000 - p;
if( jj < 1000) {
for(int k = 0; k <= 100; k++) {
const int kk = k;
dp[ii][jj][kk] = min(dp[ii][jj][kk], dp[i][j][k] + ps[i]);
}
}
}
}
}
}
for(int k = 100; k >= 0; k--) {
int p = BIG;
for(int j = 0; j <= CMAX; j++) {
p = min(p, dp[n][j][k]);
}
if(p != BIG) {
cout << k << " " << p << endl;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
int dp[128][128][1024];
int n;
int P[128];
void init() {
for(int i = 0; i < 128; ++i) {
for(int j = 0; j < 128; ++j) {
for(int k = 0; k < 1024; ++k) {
dp[i][j][k] = -1;
}
}
}
}
int main() {
for(;;) {
init();
scanf("%d", &n);
if( n == 0 ) break;
for(int i = 0; i < n; ++i) {
scanf("%d", &P[i]);
}
dp[0][0][0] = 0;
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
for(int k = 0; k < 1024; ++k) {
if( dp[i][j][k] == -1 ) continue;
// step 1
dp[i+1][j][k] = std::max(dp[i+1][j][k], dp[i][j][k]);
// step 2
int n1kyen = (P[i] + 999) / 1000;
int rem = dp[i][j][k] + n1kyen * 1000 - P[i];
int next_num500yen = j + (rem >= 500 ? 1 : 0);
int next_num1kyen = k + n1kyen;
int next_rem = rem >= 500 ? rem - 500 : rem;
int& next = dp[i+1][next_num500yen][next_num1kyen];
next = std::max(next, next_rem);
}
}
}
int res = (1 << 28);
int max = -1;
for(int j = n; j >= 0; --j) {
for(int k = 0; k < 1024; ++k) {
if( dp[n][j][k] == -1 ) continue;
int cost = k * 1000 - 500 * j - dp[n][j][k];
res = std::min(res, cost);
}
if( res != (1 << 28) ) {
max = j;
break;
}
}
printf("%d %d\n", max, res);
}
return 0;
} |
#include<iostream>
#include<vector>
#include<functional>
#include<algorithm>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
typedef pair<int, int> P;
void solve() {
int N; cin >> N;
if (N == 0)exit(0);
vector<int>p(N);
REP(i, N) {
cin >> p[i];
}
//dp[i][j]=i番目までで、おつりがj円の時の、{500円玉の枚数のmax,消費金額のmin}
vector<vector<P>>dp(N + 1, vector<P>(50500, { -1,1e8 }));
dp[0][0] = { 0,0 };
REP(i, N) {
REP(j, 50005) {
if (dp[i][j].first <0)continue;
int otsuri = (1000 - p[i] % 1000) % 1000;
int cnt = dp[i][j].first;
int cost = dp[i][j].second;
//買わない
if (cnt>dp[i + 1][j].first) {
dp[i + 1][j] = { cnt,cost };
}
else if (cnt == dp[i + 1][j].first&&cost<dp[i + 1][j].second) {
dp[i + 1][j] = { cnt,cost };
}
//おつりが500円以上の時(1000円で買えば500円がもらえる)
if (otsuri >= 500) {
//500円のmaxを増やせるとき
if (cnt + 1>dp[i + 1][j + otsuri - 500].first) {
dp[i + 1][j + otsuri - 500] = { cnt + 1,cost + p[i] };
}
//消費金額のminを小さくできるとき
else if (cnt + 1 == dp[i + 1][j + otsuri - 500].first&&cost + p[i]<dp[i + 1][j + otsuri - 500].second) {
dp[i + 1][j + otsuri - 500] = { cnt + 1,cost + p[i] };
}
}
else {
//手持ちのおつりと合わせて500円がもらえる
if (j + otsuri >= 500) {
int d = 500 - otsuri;//500円との差額
//買うけど500円はもらわない
if (cnt>dp[i + 1][j + otsuri].first) {
dp[i + 1][j + otsuri] = { cnt,cost + p[i] };
}
else if (cnt == dp[i + 1][j + otsuri].first&&cost + p[i]<dp[i + 1][j + otsuri].second) {
dp[i + 1][j + otsuri] = { cnt,cost + p[i] };
}
//500円のmaxを増やせるとき
if (cnt + 1>dp[i + 1][j - d].first) {
dp[i + 1][j - d] = { cnt + 1,cost + p[i] };
}
//消費金額のminを小さくできるとき
else if (cnt + 1 == dp[i + 1][j - d].first && cost + p[i]<dp[i + 1][j - d].second) {
dp[i + 1][j - d] = { cnt + 1,cost + p[i] };
}
}
else {
if (cnt>dp[i + 1][j + otsuri].first) {
dp[i + 1][j + otsuri] = { cnt,cost + p[i] };
}
else if (cnt == dp[i + 1][j + otsuri].first&&cost + p[i]<dp[i + 1][j + otsuri].second) {
dp[i + 1][j + otsuri] = { cnt,cost + p[i] };
}
}
}
}
}
int cnt_max = 0;
REP(j, 50001) {
cnt_max = max(cnt_max, dp[N][j].first);
}
int mn_cost = 1e9;
REP(j, 50001) {
if (dp[N][j].first == cnt_max) {
mn_cost = min(mn_cost, dp[N][j].second);
}
}
cout << cnt_max << " " << mn_cost << endl;
}
int main() {
while (true)solve();
}
|
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
P dp[105][500*55];
int main(){
int n;
while(cin>>n, n){
memset(dp,-1,sizeof(dp));
dp[0][0]=P(0,0);
P ans=P(0,0);
for(int i=0;i<n;i++){
int p;
cin>>p;
for(int j=0;j<500*55;j++){
if(dp[i][j]==P(-1,-1)) continue;
dp[i+1][j]=max(dp[i+1][j],dp[i][j]);
if(p%1000){
int rest=1000-p%1000, add500=0;
if(rest>=500) add500++, rest-=500;
int idx=min(j+rest,500*55-1);
dp[i+1][idx]=max(dp[i+1][idx],P(dp[i][j].first+add500,-(-dp[i][j].second+p)));
ans=max(ans,dp[i+1][idx]);
}
int rest=p+500;
rest%=1000;
if(j-rest<0) continue;
dp[i+1][j-rest]=max(dp[i+1][j-rest],P(dp[i][j].first+1,-(-dp[i][j].second+p)));
ans=max(ans,dp[i+1][j-rest]);
}
}
cout<<ans.first<<' '<<-ans.second<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<int(n);++i)
#define updmax(dp,x) dp=(dp.first == 0 ? x : max(dp,x))
using P = pair<int,int>;
int main(void){
int n;
while(cin>>n, n){
vector<int> p(n);
rep(i,n) cin>>p[i];
map<int,P> cur; // cur[coin] = <get,pay>
cur[0] = {0,0};
rep(i,n){
map<int,P> nxt;
for(auto &itr : cur){
int coin = itr.first;
int k = itr.second.first;
int pay = itr.second.second;
updmax(nxt[coin], P(k,pay));
pay -= p[i];
int mod = p[i]%500;
if(p[i]%1000 == 0){
if(coin>=500) updmax(nxt[coin-500], P(k+1,pay));
}else if(p[i]%1000 == 500){
updmax(nxt[coin], P(k+1,pay));
}else if(p[i]%1000 <= 500){
updmax(nxt[coin+500-mod], P(k+1, pay));
}else if(mod <= coin){
updmax(nxt[coin-mod], P(k+1,pay));
}else{
updmax(nxt[coin+500-mod], P(k,pay));
}
}
cur = move(nxt);
}
P res = {0,0};
for(auto itr : cur){
res = max(res,itr.second);
}
cout<<res.first<<" "<<-res.second<<endl;
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>
using namespace std;
#define LOG(...) printf(__VA_ARGS__)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define RSORT(c) sort((c).rbegin(),(c).rend())
#define CLR(a) memset((a), 0 ,sizeof(a))
#define WRAP(y,x,h,w) (0<=y && y<h && 0<=x && x<w)
typedef long long ll;
typedef unsigned long long ull;
typedef string str;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef vector<vd> vvd;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[] = { -1,0,1,0 }; const int dy[] = { 0,1,0,-1 };
int main() {
int n;
while (cin>>n,n) {
vi va(n);
REP(i, n)
cin >> va[i];
vector<pii> state(500 * n, {-1,9999999});
state[0] = { 0,0 };
REP(i, n) {
vector<pii> state2 = state;
REP(j, 500 * n) {
if (state[j].first != -1) {
if (va[i] % 1000 != 0 && va[i] % 1000 <= 500) {
if (state2[j + (500 - va[i] % 500) % 500].first < state[j].first + 1) {
state2[j + (500 - va[i] % 500) % 500].first = state[j].first + 1;
state2[j + (500 - va[i] % 500) % 500].second = state[j].second + va[i];
}
else if(state2[j + (500 - va[i] % 500) % 500].first == state[j].first + 1){
if (state2[j + (500 - va[i] % 500) % 500].second > state[j].second + va[i]) {
state2[j + (500 - va[i] % 500) % 500].second = state[j].second + va[i];
}
}
}
else {
//buy all1000
if (va[i] % 1000 != 0) {//1000??????????????§x%1000==0????????????????????????????§?
if (state2[j + (1000 - (va[i]%1000))].first < state[j].first) {
state2[j + (1000 - (va[i] % 1000))].first = state[j].first;
state2[j + (1000 - (va[i] % 1000))].second = state[j].second + va[i];
}
else if (state2[j + (1000 - (va[i] % 1000))].first == state[j].first) {
if (state2[j + (1000 - (va[i] % 1000))].second > state[j].second + va[i]) {
state2[j + (1000 - (va[i] % 1000))].second = state[j].second + va[i];
}
}
}
//buy want500
if (va[i] % 1000 == 0 && j >= 500) {
if (state2[j -500].first < state[j].first + 1) {
state2[j - 500].first = state[j].first + 1;
state2[j - 500].second = state[j].second + va[i];
}
else if (state2[j - 500].first == state[j].first + 1) {
if (state2[j - 500].second > state[j].second + va[i]) {
state2[j - 500].second = state[j].second + va[i];
}
}
}
if (va[i] % 1000 > 500 && j >= va[i] % 500) {
if (state2[j - (va[i] % 500)].first < state[j].first + 1) {
state2[j - (va[i] % 500)].first = state[j].first + 1;
state2[j - (va[i] % 500)].second = state[j].second + va[i];
}
else if (state2[j - (va[i] % 500)].first == state[j].first + 1) {
if (state2[j - (va[i] % 500)].second > state[j].second + va[i]) {
state2[j - (va[i] % 500)].second = state[j].second + va[i];
}
}
}
}
}
}
state = state2;
}
int ans=-1, ans2=9999999;
REP(i, 500 * n) {
if (ans < state[i].first) {
ans = state[i].first;
ans2= state[i].second;
}
else if (ans == state[i].first)
{
if (ans2 > state[i].second) {
ans2 = state[i].second;
}
}
}
cout << ans << " " << ans2 << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int M = 100000;
int main() {
int n;
while (cin >> n, n) {
auto p = vector<int>(n);
for (int i = 0; i < n; ++i) cin >> p[i];
auto dp1 = vector<vector<int>>(n + 1, vector<int>(M, -1));
auto dp2 = vector<vector<int>>(n + 1, vector<int>(M, 100 * 5000));
dp1[0][0] = dp2[0][0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < M; ++j) {
dp1[i + 1][j] = dp1[i][j];
dp2[i + 1][j] = dp2[i][j];
}
int change = (1000 - p[i] % 1000) % 1000;
for (int cur = 0; cur < M; ++cur) {
if (dp1[i][cur] == -1) continue;
int canGet = (cur + change >= 500);
int nxt = cur + change - 500 * canGet;
if (dp1[i + 1][nxt] < dp1[i][cur] + canGet) {
dp1[i + 1][nxt] = dp1[i][cur] + canGet;
dp2[i + 1][nxt] = dp2[i][cur] + p[i];
} else if (dp1[i + 1][nxt] == dp1[i][cur] + canGet) {
dp2[i + 1][nxt] = min(dp2[i + 1][nxt], dp2[i][cur] + p[i]);
}
}
}
int ans1 = -1, ans2 = 100 * 5000;
for (int j = 0; j < M; ++j) ans1 = max(ans1, dp1[n][j]);
for (int j = 0; j < M; ++j) if (dp1[n][j] == ans1) ans2 = min(ans2, dp2[n][j]);
cout << ans1 << ' ' << ans2 << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#define int long long
using namespace std;
class Solver {
};
signed main() {
while (true) {
int n;
cin >> n;
if (n == 0)break;
vector<int> prices(n, 0);
for (int i = 0; i < n; i++) {
cin >> prices[i];
}
int change = 50000;
int cnt = 100;
vector <tuple<int, int>> dp(change + 500);
for (int i = 0; i < change + 500; i++)dp[i] = make_tuple(0, 1e9);
get<1>(dp[0]) = 0;
for (int i = 0; i < n; i++) {
vector <tuple<int, int>> next(change + 500);
for (int j = 0; j < change + 500; j++)next[j] = make_tuple(0, 1e9);
for (int j = 0; j < change; j++) {
int cnt_tmp = get<0>(dp[j]);
int price_tmp = get<1>(dp[j]);
if (price_tmp == 1e9)continue;
if(get<0>(next[j])<cnt_tmp
|| (get<0>(next[j]) == cnt_tmp
&& get<1>(next[j]) > price_tmp)) {
next[j] = make_tuple(cnt_tmp, price_tmp);
}
int next_price = price_tmp + prices[i];
if (prices[i] % 1000 == 0) {
if (j >= 500) {
int next_change = j - 500;
if (get<0>(next[next_change]) < cnt_tmp + 1
|| (get<0>(next[next_change]) == cnt_tmp + 1
&& get<1>(next[next_change]) > next_price)) {
next[next_change] = make_tuple(cnt_tmp + 1, next_price);
}
}
continue;
}
if (prices[i] % 1000 <= 500) {
int next_change = j + 500 - (prices[i] % 1000);
if (get<0>(next[next_change]) < cnt_tmp + 1
|| (get<0>(next[next_change]) == cnt_tmp + 1
&& get<1>(next[next_change]) > next_price)) {
next[next_change] = make_tuple(cnt_tmp + 1, next_price);
}
}
else {
int next_change = j + 1000 - (prices[i] % 1000);
if (get<0>(next[next_change]) < cnt_tmp
|| (get<0>(next[next_change]) == cnt_tmp
&& get<1>(next[next_change]) > next_price)) {
next[next_change] = make_tuple(cnt_tmp, next_price);
}
if (j >= prices[i] % 500) {
next_change = j - (prices[i] % 500);
if (get<0>(next[next_change]) < cnt_tmp + 1
|| (get<0>(next[next_change]) == cnt_tmp + 1
&& get<1>(next[next_change]) > next_price)) {
next[next_change] = make_tuple(cnt_tmp + 1, next_price);
}
}
}
}
dp = next;
}
int res_cnt = 0;
int res_price = 1e9;
for (int i = 0; i < change;i++) {
int cnt_tmp = get<0>(dp[i]);
int price_tmp = get<1>(dp[i]);
if (res_cnt < cnt_tmp
|| (res_cnt == cnt_tmp && price_tmp < res_price)) {
res_cnt = cnt_tmp;
res_price = price_tmp;
}
}
cout << res_cnt << " " << res_price << endl;
}
}
|
#include <iostream>
#include <vector>
void change( int kingaku, int a[] )
{
a[0] = kingaku / 1000;
kingaku -= a[0] * 1000;
a[1] = kingaku / 500;
kingaku -= a[1] * 500;
a[2] = kingaku;
}
int main(void)
{
while ( true ) {
int n;
std::cin >> n;
if ( n == 0 ) break;
std::vector<int> omiyage(n);
for ( int i = 0; i < n; ++i ) {
std::cin >> omiyage[i];
}
const int NC = 5000;
int now = 0;
static int kingaku[2][NC];
static unsigned char m[2][NC];
for ( int j = 0; j < NC; ++j ) {
m[1-now][j] = 0;
kingaku[1-now][j] = 0;
}
for ( int i = 1; i <= n; ++i ) {
for ( int j = 0; j < NC; ++j ) {
int a[3];
m[now][j] = m[1-now][j];
kingaku[now][j] = kingaku[1-now][j];
for ( int v = j%100 - 100; v <= j; v += 100 ) {
int u = v;
if ( u < 0 ) u = 0;
int l = ((omiyage[n-i] - u) + 999) / 1000;
if ( l < 0 ) continue;
change( l * 1000 + u - omiyage[n-i], a);
if ( a[2] + j - u >= NC ) continue;
if ( m[now][j] == a[1] + m[1-now][a[2] + j - u] && kingaku[now][j] > omiyage[n-i] + kingaku[1-now][a[2] + j - u] ) {
m[now][j] = a[1] + m[1-now][a[2] + j - u];
kingaku[now][j] = omiyage[n-i] + kingaku[1-now][a[2] + j - u];
} else if ( m[now][j] < a[1] + m[1-now][a[2] + j - u]) {
m[now][j] = a[1] + m[1-now][a[2] + j - u];
kingaku[now][j] = omiyage[n-i] + kingaku[1-now][a[2] + j - u];
}
}
}
now = 1 - now;
}
now = 1 - now;
std::cout << (int)m[now][0] << " " << kingaku[now][0] << std::endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int n;
int a[105];
int dp[105][100005];
int DP[105][100005];
int main(){
while(1){
cin>>n;
if(n==0)break;
for(int i=1;i<=n;i++)cin>>a[i];
fill(dp[0],dp[105],-1e9);
fill(DP[0],DP[105],1e9);
int ans=0,ANS=1e9;
dp[0][0]=0;
DP[0][0]=0;
for(int i=1;i<=n;i++){
for(int j=0;j<=100000;j++){
int A=a[i]%1000;
if(A==0)A=1000;
dp[i][j]=dp[i-1][j];
DP[i][j]=DP[i-1][j];
if(A<=500){
int k=1000-A-500;
if(j-k>=0){
int d=dp[i-1][j-k]+1;
int D=DP[i-1][j-k]+a[i];
if( (d==dp[i][j]&&D<DP[i][j]) || d>dp[i][j]){
dp[i][j]=d;
DP[i][j]=D;
}
}
}else{
int k=1000-A;
if(j-k>=0){
int d=dp[i-1][j-k];
int D=DP[i-1][j-k]+a[i];
if( (d==dp[i][j]&&D<DP[i][j]) || d>dp[i][j]){
dp[i][j]=d;
DP[i][j]=D;
}
}
if(j+A-500<=100000){
int d=dp[i-1][j+A-500]+1;
int D=DP[i-1][j+A-500]+a[i];
if( (d==dp[i][j]&&D<DP[i][j]) || d>dp[i][j]){
dp[i][j]=d;
DP[i][j]=D;
}
}
}
if( (ans==dp[i][j]&&DP[i][j]<ANS) || ans<dp[i][j] ){
ans=dp[i][j];
ANS=DP[i][j];
}
}
}
cout<<ans<<' '<<ANS<<endl;
}
return 0;
} |
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int inf = 1012345678;
int main() {
int N;
while (cin >> N, N) {
vector<int> A(N);
for (int i = 0; i < N; ++i) cin >> A[i];
vector<pair<int, int> > dp = { make_pair(0, 0) };
for (int i = 0; i < N; ++i) {
vector<pair<int, int> > ndp((i + 1) * 1000 + 1, make_pair(-inf, inf));
for (int j = 0; j <= i * 1000; ++j) {
ndp[j] = max(ndp[j], dp[j]);
int reward = (500 - A[i] % 500) % 500;
ndp[j + reward] = max(ndp[j + reward], make_pair(dp[j].first, dp[j].second - A[i]));
int loss = 500 - (1000 - A[i] % 1000) % 1000;
if (j >= loss) ndp[j - loss] = max(ndp[j - loss], make_pair(dp[j].first + 1, dp[j].second - A[i]));
}
dp = ndp;
}
pair<int, int> ans = *max_element(dp.begin(), dp.end());
cout << ans.first << ' ' << -ans.second << endl;
}
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FOREQ(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPEQ(i, n) FOREQ(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
template <typename T> inline int size(const T& x) { return x.size(); }
int main() {
cin.tie(0); ios_base::sync_with_stdio(false);
int n;
while (cin >> n, n) {
vector<int> prices(n);
REP(i, n) cin >> prices[i];
static const int MAX_COIN = 100*500;
vector<pair<int, int>> dp[2];
REP(i, 2) dp[i].resize(MAX_COIN);
dp[0][0] = make_pair(0, 0);
FOR(i, 1, MAX_COIN) dp[0][i] = make_pair(-10000000, 0);
REP(i, n) {
int curr = i % 2;
int next = (i+1) % 2;
REP(coin, MAX_COIN) {
dp[next][coin] = make_pair(-10000000, 0);
}
REP(coin, MAX_COIN) {
auto c = dp[curr][coin];
int change = (1000 - prices[i]%1000) % 1000;
if (change >= 500) {
// 1000????????§?????£???500?????????????????\?????´???
int next_coin = coin + change - 500;
if (next_coin < MAX_COIN)
dp[next][next_coin] = max(dp[next][next_coin], make_pair(c.first+1, c.second-prices[i]));
continue;
}
// ??????????????´???
dp[next][coin] = max(dp[next][coin], c);
if (change + coin >= 500) {
// ????????´?????§????°???????????????°500?????????????????\?????´???
int next_coin = coin + change - 500;
if (next_coin < MAX_COIN)
dp[next][next_coin] = max(dp[next][next_coin], make_pair(c.first+1, c.second-prices[i]));
} else {
// ????????´?????§???500???????????\?????????????????´???
int next_coin = coin + change;
if (next_coin < MAX_COIN)
dp[next][next_coin] = max(dp[next][next_coin], make_pair(c.first, c.second-prices[i]));
}
}
}
auto ans = make_pair(-10000000, 0);
REP(coin, MAX_COIN) ans = max(ans, dp[n%2][coin]);
cout << ans.first << ' ' << -ans.second << endl;
}
} |
#include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define FORR(i, b, a) for (int i = (a - 1); i >= (b); i--)
#define ALL(vec) (vec).begin(), (vec).end()
int get_int() {
int tmp;
cin >> tmp;
return tmp;
}
int main() {
while (true) {
const int n = get_int();
if (n == 0) return 0;
auto dp = vector<vector<int>>(n + 10, vector<int>(5 * n + 50, -1));
dp[0][0] = 0;
REP(ni, n) {
auto p = get_int();
int rest = p % 1000;
int sheet = p / 1000;
if (rest == 0) {
FORR(i, 0, n + 1) FORR(j, 0, 5 * n + 1) {
// 小銭と1000円で買う
if (i - 1 >= 0 and j - sheet + 1 >= 0 and
dp[i - 1][j - sheet + 1] >= 0) {
int buy = dp[i - 1][j - sheet + 1] - 500;
dp[i][j] = max(dp[i][j], buy);
}
}
} else if (rest > 500) {
FORR(i, 0, n + 1) FORR(j, 0, 5 * n + 1) {
// 1000円で買う (小銭のみ得る)
if (j - 1 - sheet >= 0 and dp[i][j - 1 - sheet] >= 0) {
int buy = dp[i][j - 1 - sheet] + 1000 - rest;
dp[i][j] = max(dp[i][j], buy);
}
// 小銭と1000円で買う
if (i - 1 >= 0 and j - sheet >= 0 and dp[i - 1][j - sheet] >= 0) {
int buy = dp[i - 1][j - sheet] - (rest - 500);
dp[i][j] = max(dp[i][j], buy);
}
}
} else {
// 買うに決まっている,ついでにuse_get円得ちゃう
int use_get = 500 - rest;
FORR(i, 1, n + 1) FORR(j, sheet, 5 * n + 1) {
if (dp[i - 1][j - sheet] < 0) continue;
dp[i][j] = max(dp[i][j], dp[i - 1][j - sheet] + use_get);
}
}
}
[&]() {
// C++クソでは
FORR(i, 0, n + 1) {
int min_val = 10000000;
bool is_ok = false;
FOR(j, 0, 5 * n + 1) {
if (dp[i][j] == -1) continue;
auto val = -(dp[i][j] - (500 * i) - (1000 * j));
if (min_val > val) {
min_val = val;
is_ok = true;
}
}
if (is_ok) {
cout << i << " " << min_val << endl;
return;
}
}
}();
}
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(int argc, char *argv[])
{
const int BIG = 1000000;
const int CMAX = 25000;
for(;;) {
int n;
cin >> n;
if(n == 0) break;
vector<int> ps;
for(int i = 0; i < n; i++) {
int p; cin >> p; ps.push_back(p);
}
// shop : at most 100
// change : at most 49900... too much? to get 50, max = 25000
// # of 500 got so far : at most 100
// value : minimum payment
vector<vector<int>> dp(CMAX+1, vector<int>(101, BIG));
vector<vector<int>> dpnew(CMAX+1, vector<int>(101, BIG));
dpnew[0][0] = 0;
int cmax = 0;
for(int i = 0; i < n; i++) {
const int ii = i + 1;
// not buying
for(int j = 0; j <= cmax; j++) {
for(int k = 0; k <= i; k++) {
dp[j][k] = dpnew[j][k];
}
}
// buying
for(int j = 0; j <= cmax; j++) {
const int p = ps[i] % 1000;
if(p != 0 && p <= 500) { // got 500!
const int jj = min(j + 500 - p, CMAX);
cmax = min(max(cmax, jj), CMAX);
for(int k = 0; k <= i; k++) {
const int kk = k + 1;
if(dpnew[jj][kk] > dp[j][k] + ps[i]) {
dpnew[jj][kk] = dp[j][k] + ps[i];
}
}
} else {
// get 500 if possible!
const int q = (p == 0 ? 1000 : p) - 500;
if(j >= q) {
const int jj = j - q;
for(int k = 0; k <= i; k++) {
const int kk = k + 1;
if(dpnew[jj][kk] > dp[j][k] + ps[i]) {
dpnew[jj][kk] = dp[j][k] + ps[i];
}
}
} else { // get change
const int jj = j + 1000 - p;
cmax = min(max(cmax, jj), CMAX);
if( jj < 1000) {
for(int k = 0; k <= i; k++) {
const int kk = k;
if(dpnew[jj][kk] > dp[j][k] + ps[i]) {
dpnew[jj][kk] = dp[j][k] + ps[i];
}
}
}
}
}
}
}
for(int k = 100; k >= 0; k--) {
int p = BIG;
for(int j = 0; j <= cmax; j++) {
p = min(p, dpnew[j][k]);
}
if(p != BIG) {
cout << k << " " << p << endl;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define FOR(i,s,x) for(int i=s;i<(int)(x);i++)
#define REP(i,x) FOR(i,0,x)
#define ALL(c) c.begin(), c.end()
#define DUMP( x ) cerr << #x << " = " << ( x ) << endl
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = {0, 1, 0, -1};
pair<int, int> dp[101][50001];
bool used[101][50001];
int N, P[100];
pair<int, int> dfs(int idx, int coins) {
if (idx == N) return make_pair(0, 0);
if (used[idx][coins]) return dp[idx][coins];
used[idx][coins] = true;
// not buy;
pair<int, int> ret = dfs(idx + 1, coins);
// buy only with bills
int change = (1000 - P[idx] % 1000) % 1000;
int cnt, money; tie(cnt, money) = dfs(idx + 1, coins + change % 500);
ret = max(ret, make_pair(cnt + (change >= 500), money - P[idx]));
// buy with bills & coins to get 500
if ((P[idx] + 500) % 1000 <= coins) {
int cnt, money; tie(cnt, money) = dfs(idx + 1, coins - (P[idx] + 500) % 1000);
ret = max(ret, make_pair(cnt + 1, money - P[idx]));
}
return dp[idx][coins] = ret;
}
int main() {
// use scanf in CodeForces!
cin.tie(0);
ios_base::sync_with_stdio(false);
while (true) {
cin >> N;
if (not N) break;
REP(i, N) cin >> P[i];
memset(used, 0, sizeof(used));
int cnt, money; tie(cnt, money) = dfs(0, 0);
cout << cnt << ' ' << -money << endl;
}
return 0;
} |
#include <iostream>
#define inf 1000000000
using namespace std;
struct state{
int coin, cost;
state(){}
state(int c, int s){
coin = c, cost = s;
}
bool operator<(const state& ope)const{
return coin < ope.coin || (coin == ope.coin && cost > ope.cost);
}
};
int n;
int p[105];
state dp[105][250005];
int main(void)
{
while(1){
cin >> n;
if(n == 0) break;
for(int i = 1; i <= n; i++) cin >> p[i];
for(int i = 0; i <= n; i++){
for(int j = 0; j < 250005; j++){
dp[i][j] = state(-inf, inf);
}
}
dp[0][0] = state(0, 0);
int pay, ret;
for(int i = 0; i < n; i++){
for(int j = 0; j < 250005; j++){
dp[i+1][j] = max(dp[i+1][j], dp[i][j]);
pay = (p[i+1] + 999) / 1000 * 1000;
ret = pay - p[i+1];
if(ret >= 500) dp[i+1][j+ret-500] = max(dp[i+1][j+ret-500], state(dp[i][j].coin+1, dp[i][j].cost+p[i+1]));
else dp[i+1][j+ret] = max(dp[i+1][j+ret], state(dp[i][j].coin, dp[i][j].cost+p[i+1]));
ret = (p[i+1] + 500) % 1000;
if(ret <= j){
dp[i+1][j-ret] = max(dp[i+1][j-ret], state(dp[i][j].coin+1, dp[i][j].cost+p[i+1]));
}
}
}
state ans = state(-inf, inf);
for(int i = 0; i < 250005; i++){
ans = max(ans, dp[n][i]);
}
cout << ans.coin << " " << ans.cost << endl;
}
return 0;
} |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int INF = (int)1e9 + 7;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first > b.first;
return a.second < b.second;
}
int main() {
int n;
while (cin >> n, n) {
vector<int> p(n);
for (int &pi: p) cin >> pi;
vector<pair<int, int>> cur(50001, {-INF, INF}), nxt(cur);
cur[0] = {0, 0};
int rest_ma = 0;
for (int pi: p) {
int mod = pi % 1000;
if (1 <= mod && mod <= 500) {
int rev = 1000 - mod - 500;
rest_ma += rev;
for (int rest = rest_ma; rest >= rev; rest--) {
nxt[rest] = min(nxt[rest], {
cur[rest - rev].first + 1, cur[rest - rev].second + pi
}, cmp);
}
} else {
int rev = (1000 - mod) % 1000;
int need = (mod + 500) % 1000;
rest_ma += max(rev, need);
for (int rest = 0; rest <= rest_ma; rest++) {
nxt[rest] = cur[rest];
}
for (int rest = rest_ma; rest >= rev; rest--) {
nxt[rest] = min(nxt[rest], {
cur[rest - rev].first, cur[rest - rev].second + pi
}, cmp);
}
for (int rest = need; rest <= rest_ma; rest++) {
nxt[rest - need] = min(nxt[rest - need], {
cur[rest].first + 1, cur[rest].second + pi
}, cmp);
}
}
swap(cur, nxt);
}
auto res_p = *min_element(cur.begin(), cur.end(), cmp);
cout << res_p.first << " " << res_p.second << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
#define int long long
#define rep(i,n) for(int i = 0;i < (n) ;i++)
using P = pair<int,int>;
int n;
int q[100];
int p[100];
P dp[101][50000];
P operator+(P a, P b) {
return P(a.first+b.first, a.second+b.second);
}
void init(void) {
rep(i,n+1) {
rep(j,50000) {
dp[i][j] = P(-1,1);
}
}
}
P rec(int i, int r) {
if (dp[i][r] != P(-1,1)) return dp[i][r];
if (i >= n) return dp[i][r] = P(0,0);
if (1 <= q[i] && q[i] <= 500) {
P a = P(1,-p[i]) + rec(i + 1, r + 500 - q[i]);
P b = rec(i + 1, r);
return dp[i][r] = max(a,b);
}
int qq = q[i];
if (qq == 0) qq = 1000;
P a = P(-1,1), b;
if (r >= qq - 500) {
a = P(1, -p[i]) + rec(i + 1, r - qq + 500);
}
b = P(0, -p[i]) + rec(i + 1, r + 1000 - qq);
P c = rec(i+1, r);
return dp[i][r] = max(a, max(b,c));
}
void solve(void) {
init();
P ans = rec(0,0);
cout << ans.first << " " << -ans.second << endl;
}
signed main (void) {
while(true) {
cin >> n;
if (n == 0) break;
rep(i,n) {
cin >> p[i];
q[i] = p[i] % 1000;
}
solve();
}
}
|
#include <bits/stdc++.h>
#define MOD 1000000007
typedef long long ll;
using namespace std;
int N;
int dp[2][101][100050];
const int INF=1e9;
void chmin(int &a,int b){
if(a>b) a=b;
}
void solve(){
vector<int> P(N);
for(int i=0;i<N;i++) cin>>P[i];
for(int i=0;i<2;i++){
for(int j=0;j<=N;j++){
for(int k=0;k<=1000*N;k++){
dp[i][j][k]=INF;
}
}
}
dp[0][0][0]=0;
int t=0;
int rest=0;
for(int i=0;i<N;i++){
for(int j=0;j<=i;j++){
for(int k=0;k<=rest;k++){
if(dp[t][j][k]==INF) continue;
chmin(dp[1-t][j][k],dp[t][j][k]);
int thousand=(1000-P[i]%1000)%1000;
rest=max(rest,k+thousand);
if(thousand>=500) chmin(dp[1-t][j+1][k+thousand-500],dp[t][j][k]+P[i]);
else chmin(dp[1-t][j][k+thousand],dp[t][j][k]+P[i]);
int z=0;
if(thousand==0) z=500;
else if(thousand<500) z=500-thousand;
if(z==0) continue;
if(z>k) continue;
chmin(dp[1-t][j+1][k-z],dp[t][j][k]+P[i]);
}
}
for(int j=0;j<=i;j++){
for(int k=0;k<=rest;k++){
dp[t][j][k]=INF;
}
}
t=1-t;
}
int ma=0,mi=INF;
for(int j=N;j>=0;j--){
for(int k=0;k<=1000*N;k++){
if(dp[t][j][k]==INF) continue;
ma=j;
mi=min(mi,dp[t][j][k]);
}
if(ma>0) break;
}
cout<<ma<<" "<<mi<<endl;
}
int main(){
while(1){
cin>>N;
if(N==0) break;
solve();
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define INF 1<<30
#define LINF 1LL<<60
ll dp[105][105][505];
int main() {
cin.tie(0); ios::sync_with_stdio(false);
ll n;
while (cin >> n, n) {
vector<ll> p(n);
for (int i = 0; i < n;i++) cin >> p[i];
/* dp[N][500yen cnt][1000yen cnt] := cost */
for (int i = 0; i < 105;i++)for (int j = 0; j < 105;j++)for (int k = 0; k < 505;k++)dp[i][j][k] = INF;
dp[0][0][0] = 0;
for (int i = 0; i < n;i++) {
for (int j = 0; j < 105;j++) {
for (int k = 0; k < 505;k++) {
if (dp[i][j][k] == INF)continue;
int coin = 1000 * k - dp[i][j][k] - 500 * j;
dp[i + 1][j][k] = min(dp[i + 1][j][k], dp[i][j][k]);
/*cout << i << " " << j << " " << k << endl;
cout << dp[i][j][k] << " " << p[i] << endl;
cout << coin << endl;
cout << "---------------------------------" << endl;*/
int x = p[i] + 500;
int th = x / 1000;
int c = x % 1000;
if (coin >= c) {
dp[i + 1][j + 1][k + th] = min(dp[i + 1][j + 1][k + th], dp[i][j][k] + p[i]);
}
th = p[i] / 1000;
if (p[i] % 1000 != 0)th++;
c = 1000 * th - p[i];
if (c >= 500) {
dp[i + 1][j + 1][k +th] = min(dp[i + 1][j + 1][k + th], dp[i][j][k] + p[i]);
}
else {
dp[i + 1][j][k + th] = min(dp[i + 1][j][k + th], dp[i][j][k] + p[i]);
}
}
}
}
ll ans1, ans2 = INF;
for (int i = 104; i >= 0;i--) {
bool f = false;
for (int j = 504; j >= 0; j--) {
if (dp[n][i][j] == INF)continue;
if (!f) { ans1 = i; f = true; }
ans2 = min(ans2, dp[n][i][j]);
}
if (f)break;
}
cout << ans1 << " " << ans2 << endl;
}
return 0;
} |
// finish date: 2018/06/21
#include <iostream>
#include <cmath>
#include <vector>
#include <bitset>
#include <algorithm>
#include <stack>
#include <queue>
#include <map>
#include <climits>
#include <functional>
using namespace std;
#define FOR(i, a, b) for(int (i)=a;(i)<(b);(i)++)
#define rep(i, n) FOR(i,0,n)
#define ll long long
#define vi vector<int>
#define vvi vector<vector<int>>
#define vvvi vector<vector<vector<int>>>
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vd vector<double>
#define vvd vector<vector<double>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
#define vs vector<string>
#define vc vector<char>
#define vvc vector<vector<char>>
#define pii pair<int,int>
const int bigmod = 1000000007;
#define INF 1050000000
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) break;
vi p(n);
rep(i, n) {
cin >> p[i];
}
int maxDP = n * 1000;
vector<pii > DP(maxDP, pii(-1, -1));
DP[0] = pii(0, 0);
vector<pii > newDP;
rep(i, n) {
newDP = vector<pii >(maxDP, pii(-1, -1));
int otsuri = 1000 - p[i] % 1000;
if (otsuri == 1000) otsuri = 0;
for (int j = maxDP - 1; j >= 0; j--) {
if (DP[j] == pii(-1, -1)) continue;
bool con1 = newDP[j + otsuri].first < DP[j].first;
bool con2 = newDP[j + otsuri].first == DP[j].first;
bool con3 = newDP[j + otsuri].second > DP[j].second + p[i];
if (con1 || (con2 && con3)) {
newDP[j + otsuri] = DP[j];
newDP[j + otsuri].second += p[i];
}
}
rep(j, maxDP) {
if (newDP[j] == pii(-1, -1)) continue;
if (j >= 500) {
bool con1 = newDP[j - 500].first < newDP[j].first + 1;
bool con2 = newDP[j - 500].first == newDP[j].first + 1;
bool con3 = newDP[j - 500].second > newDP[j].second;
if (con1 || (con2 && con3)) {
newDP[j - 500] = newDP[j];
newDP[j - 500].first++;
}
}
}
rep(j, maxDP) {
if (DP[j].first > newDP[j].first || (DP[j].first == newDP[j].first && DP[j].second < newDP[j].second)) {
newDP[j] = DP[j];
}
}
DP = newDP;
}
int ma = -1;
int ansMoney = 0;
rep(i, maxDP) {
if (DP[i].first > ma || (DP[i].first == ma && DP[i].second < ansMoney)) {
ma = DP[i].first;
ansMoney = DP[i].second;
}
}
cout << ma << " " << ansMoney << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
while(cin>>n,n){
vector<int> p(n);
for(int i=0;i<n;i++) cin>>p[i];
const int INF=1e8;
vector<vector<pair<int,int>>> dp(n+1,vector<pair<int,int>>(100000,make_pair(-INF,INF)));
dp[0][0]=make_pair(0,0);
for(int i=0;i<n;i++){
for(int j=0;j<dp[i].size();j++){
if(0<p[i]%1000 && p[i]%1000<=500){
pair<int,int> x=make_pair(dp[i][j].first+1,dp[i][j].second-p[i]);
int to=j+500-p[i]%1000;
if(to<dp[i+1].size()){
dp[i+1][to]=max(dp[i+1][to],x);
}
}
else if(500<p[i]%1000){
int to=j+1000-p[i]%1000;
if(to<dp[i+1].size()){
dp[i+1][to]=max(dp[i+1][to],make_pair(dp[i][j].first,dp[i][j].second-p[i]));
}
to=j-(p[i]+500)%1000;
if(to>=0){
dp[i+1][to]=max(dp[i+1][to],make_pair(dp[i][j].first+1,dp[i][j].second-p[i]));
}
}
else{
if(j>=500) dp[i+1][j-500]=max(dp[i+1][j-p[i]%1000-500],make_pair(dp[i][j].first+1,dp[i][j].second-p[i]));
}
dp[i+1][j]=max(dp[i][j],dp[i+1][j]);
}
}
pair<int,int> res=make_pair(-INF,INF);
for(int i=0;i<dp[n].size();i++){
res=max(res,dp[n][i]);
}
cout<<res.first<<" "<<-res.second<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define INF 100000000
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int n;
int p[101];
P dp[101][50001];
P max_get(P a,P b){
if(a.first>b.first){
return a;
}
if(a.first<b.first){
return b;
}
return (a.second<=b.second)?a:b;
}
int main(void){
while(1){
scanf("%d",&n);
if(n==0)break;
for(int i=0;i<n;i++){
scanf("%d",&p[i]);
}
for(int i=0;i<=n;i++){
for(int j=0;j<=50000;j++){
dp[i][j]=P(0,INF);
}
}
dp[0][0]=P(0,0);
for(int i=0;i<n;i++){
int need=(p[i]%1000)-500;
if(need<0)need+=1000;
int oturi=1000-(p[i]%1000);
if(oturi==1000)oturi=0;
for(int j=0;j<=50000;j++){
if(dp[i][j].second!=INF){
dp[i+1][j]=max_get(dp[i+1][j],dp[i][j]);
if(p[i]%1000<500 && ((p[i]%1000)!=0)){
P np=dp[i][j];
np.first++;
np.second+=p[i];
dp[i+1][j+oturi-500]=max_get(dp[i+1][j+oturi-500],np);
}else{
if(j>=need){
P np=dp[i][j];
np.first++;
np.second+=p[i];
dp[i+1][j-need]=max_get(dp[i+1][j-need],np);
}else{
P np=dp[i][j];
np.second+=p[i];
dp[i+1][j+oturi]=max_get(dp[i+1][j+oturi],np);
}
}
}
}
}
int r1=0,r2=0;
for(int i=0;i<=50000;i++){
if(dp[n][i].second!=INF){
if(r1==dp[n][i].first && r2>dp[n][i].second){
r1=dp[n][i].first;
r2=dp[n][i].second;
}
if(r1<dp[n][i].first){
r1=dp[n][i].first;
r2=dp[n][i].second;
}
}
}
printf("%d %d\n",r1,r2);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100;
const int MAX_MONEY = 500 * MAX_N;
int n;
int p[MAX_N];
pair<char, int> memo[MAX_N][MAX_MONEY];
inline void Change(pair<char, int> &a, pair<char, int> &b) {
if ((a.first < b.first) || (a.first == b.first && a.second > b.second))
a = b;
}
pair<char, int> Solve(int idx, int money) {
if (idx == n)
return pair<char, int>(0, 0);
auto &opt = memo[idx][money];
if (opt.second != -1)
return opt;
// idx?????????????????§????????????
opt = Solve(idx + 1, money);
// idx?????????????????§??????
if (0 < (p[idx] % 1000) && (p[idx] % 1000) <= 500) {
// 1000????????§?????????
int res = 1000 - (p[idx] % 1000) - 500 + money;
auto tmp = Solve(idx + 1, res);
tmp.first += 1;
tmp.second += p[idx];
Change(opt, tmp);
}
else if (p[idx] % 1000 == 0) {
if (500 <= money) {
int res = money - 500;
auto tmp = Solve(idx + 1, res);
tmp.first += 1;
tmp.second += p[idx];
Change(opt, tmp);
}
}
else if (500 <= money + 1000 - (p[idx] % 1000)) {
// 1000????????¨?°????money??§?????????
int res = money + 1000 - (p[idx] % 1000) - 500;
auto tmp = Solve(idx + 1, res);
tmp.first += 1;
tmp.second += p[idx];
Change(opt, tmp);
}
else {
// 1000??????????????§?????????
int res = 1000 - (p[idx] % 1000) + money;
auto tmp = Solve(idx + 1, res);
tmp.second += p[idx];
Change(opt, tmp);
}
return opt;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> n, n) {
for (int i = 0; i < n; ++i)
cin >> p[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n * 500; ++j)
memo[i][j] = pair<char, int>(0, -1);
auto res = Solve(0, 0);
cout << (int)res.first << ' ' << res.second << endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef pair<int,int>P;
P dp[111][111111];
int n,x;
void MAX(P &a,P b){
if(b.second>=1e9)return ;
if(a.first<b.first)a=b;
else if(a.first==b.first&&a.second>b.second)a=b;
}
signed main(){
while(cin>>n,n){
P ans=P(0,1e9);
r(i,111)r(j,111111)dp[i][j]=P(0,1e9);
dp[0][0]=P(0,0);
r(i,n){
cin>>x;
int a=((x%1000)?(x%1000):1000);
r(j,100000){
int A=dp[i][j].first;
int B=dp[i][j].second;
MAX(dp[i+1][j],dp[i][j]);
if(a<=500)MAX(dp[i+1][j+500-a],P(A+1,B+x));
else{
int b=((a%500)?(a%500):500);
MAX(dp[i+1][j+1000-a],P(A,B+x));
if(b<=j)MAX(dp[i+1][j-b],P(A+1,B+x));
}
}
}
r(i,111111)MAX(ans,dp[n][i]);
cout<<ans.first<<' '<<ans.second<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int sv[110];
pair<int,int> dp[2][50010];
bool cmp(pair<int,int> &A, pair<int,int> &B) {
return ( A.first < B.first ) || (A.first == B.first && A.second > B.second);
}
// first := 500円玉の枚数（多いほどいい）
// second := 消費金額（少ないほどいい）
int n;
bool solve()
{
cin >> n;
if(n == 0) return false;
for(int i = 0; i < n; ++i) {
cin >> sv[i];
}
int MAX_K = 500*n;
for(int i = 0; i < 2; ++i) {
for(int j = 0; j < MAX_K; ++j) {
dp[i][j].first = -1;
dp[i][j].second = 0;
}
}
dp[0][0].first = 0;
for(int i = 0; i < n; ++i) {
int prv = i%2;
int nxt = 1 - prv;
for(int j = 0; j < MAX_K; ++j) {
dp[nxt][j] = dp[prv][j];
}
int add = (1000 - sv[i]%1000)%1000; // 1000円札だけだしてもらえるおつり
int need = (sv[i] + 500)%1000; // 小銭も出して500円玉を得る場合に必要な金額
//cout << "add: " << add << " need: " << need << endl;
for(int j = 0; j < MAX_K; ++j) {
if(dp[prv][j].first == -1) continue;
int num = dp[prv][j].first;
int money = dp[prv][j].second;
if(add >= 500) {
// 1000円札だけ出して小銭と500円玉もらう方がいい
if(j + add - 500 >= MAX_K) continue;
pair<int,int> X = make_pair(num + 1, money + sv[i]);
if(cmp(dp[nxt][j + add - 500], X)) dp[nxt][j + add - 500] = X;
continue;
}
// 小銭も出して500円玉をもらう
if(j - need >= 0) {
pair<int,int> X = make_pair(num + 1, money + sv[i]);
if(cmp(dp[nxt][j - need], X)) dp[nxt][j - need] = X;
}
// 500円玉を諦め、1000円札だけ出して小銭を得る
if(j + add < MAX_K) {
pair<int,int> X = make_pair(num, money + sv[i]);
if(cmp(dp[nxt][j + add], X)) dp[nxt][j + add] = X;
}
}
// デバッグ
/*
for(int j = 0; j < MAX_K; ++j) {
if(dp[nxt][j].first != -1) {
cout << "j:" << j << " (" << dp[nxt][j].first << ", " << dp[nxt][j].second << ")" << endl;
}
}
*/
}
int num = 0, money = 1000000009;
int r = n%2;
for(int i = 0; i < MAX_K; ++i) {
if(dp[r][i].first == -1) continue;
if(num < dp[r][i].first) {
num = dp[r][i].first, money = dp[r][i].second;
}
else if(num == dp[r][i].first) {
money = min(money, dp[r][i].second);
}
}
cout << num << " " << money << endl;
return true;
}
int main() {
while(solve());
return 0;
}
|
//Wrong Answer
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
struct Pair {
int first, second;
Pair(int f, int s) { first = f; second = s; }
Pair() {}
bool operator < (const Pair &r) const { return (first != r.first) ? first < r.first : second < r.second; }
};
int n;
int p[100];
Pair dp[101][50001]; //dp[i][j] = ?????????0???i-1?????????????????????????????????, ???1???100?????????????¨?j????????£????????????????????¨??????500?????????-dp[i][j].first?????????????????£????????£????????????dp[i][j].second[???]??§?????????
void update(int id, int coin) {
int mod1000 = p[id] % 1000;
int mod500 = p[id] % 500;
dp[id + 1][coin] = min(dp[id][coin], dp[id + 1][coin]);
if (mod1000 == 0) {
if (coin >= 500) {
dp[id + 1][coin - 500] = min(dp[id + 1][coin - 500], Pair(dp[id][coin].first - 1, dp[id][coin].second + p[id]));
}
}
else if (mod1000 <= 500) {
dp[id + 1][coin + 500 - mod1000] = min(dp[id + 1][coin + 500 - mod1000], Pair(dp[id][coin].first - 1, dp[id][coin].second + p[id]));
}
else if (mod1000 <= 999) {
dp[id + 1][coin + 1000 - mod1000] = min(dp[id + 1][coin + 1000 - mod1000], Pair(dp[id][coin].first, dp[id][coin].second + p[id]));
if (coin >= mod1000 - 500) {
dp[id + 1][coin - mod1000 + 500] = min(dp[id + 1][coin - mod1000 + 500], Pair(dp[id][coin].first - 1, dp[id][coin].second + p[id]));
}
}
}
int main() {
while (cin >> n) {
int i, j;
if (!n) break;
for (i = 0; i < n; i++) cin >> p[i];
for (i = 0; i <= n; i++) for (j = 0; j < 500 * n; j++) dp[i][j] = Pair(1, 114514); //Be careful!!
dp[0][0] = Pair(0, 0);
for (i = 0; i < n; i++) {
for (j = 0; j < 500 * n; j++) {
if (dp[i][j].first > 0) continue; //Be careful!!
update(i, j);
}
}
Pair ans = Pair(0, 0); //Be careful!!
for (j = 0; j < 500 * n; j++) {
ans = min(ans, dp[n][j]);
}
cout << -ans.first << " " << ans.second << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
P dp[105][50005];
int p[100];
void Max(P &a,P b){a=max(a,b);}
int main(){
int n;
while(cin>>n && n){
memset(dp,-1,sizeof(dp));
for(int i=0;i<n;i++)cin>>p[i];
dp[0][0] = P(0,0);
for(int i=0;i<n;i++){
for(int j=0;j<50000;j++){
if(dp[i][j]==P(-1,-1)) continue;
int nf=dp[i][j].first,ns=dp[i][j].second-p[i];
Max(dp[i+1][j],dp[i][j]);
if(p[i]%1000==0)
{if(j>=500) Max(dp[i+1][j-500],P(nf+1,ns));}
else if(p[i]%1000<500) Max(dp[i+1][j+500-p[i]%500],P(nf+1,ns));
else if(p[i]%500<=j) Max(dp[i+1][j-p[i]%500],P(nf+1,ns));
else Max(dp[i+1][j+500-p[i]%500],P(nf,ns));
}
}
P ans(0,0);
for(int i=0;i<50000;i++) Max(ans,dp[n][i]);
cout<<ans.first<<" "<<-ans.second<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
template<class T> inline void chmax(T &a, const T &b) { if(a < b) a = b; }
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
for(int n; cin >> n && n;) {
vector<pair<int, int>> dp(1, make_pair(0, 0));
for(int i = 0; i < n; ++i) {
int price;
cin >> price;
const int need = min((i + 1) * 499, (n - i - 1) * 500);
vector<pair<int, int>> next_dp(need + 1, make_pair(-1, -1));
for(int small = 0; small < dp.size(); ++small) {
if(dp[small].first == -1) continue;
chmax(next_dp[min(small, need)], dp[small]);
const int num = dp[small].first;
const int cost = -dp[small].second;
const auto update = [&](const int pay) {
const int need_small = pay % 1000;
if(need_small > small) return;
const int change = pay - price;
const int next_small = min(small - need_small + change % 500, need);
const int next_num = num + change / 500;
const int next_cost = cost + price;
chmax(next_dp[next_small], make_pair(next_num, -next_cost));
};
update((price + 999) / 1000 * 1000);
update(price + 500);
}
dp = move(next_dp);
}
cout << dp[0].first << ' ' << -dp[0].second << endl;
}
return EXIT_SUCCESS;
} |
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
ll n, p, dp[101][50001], sum[101][50001];
int main() {
while (scanf("%lld", &n), n) {
for (ll j = 1; j <= n*500; j++) dp[0][j] = -10000, sum[0][j] = 100000000000LL;
for (ll i = 1; i <= n; i++) {
scanf("%lld", &p);
ll temp = (1000 - p % 1000);
if (temp == 1000) temp = 0;
if (temp >= 500) {
for (ll j = 0; j < temp-500; j++) dp[i][j] = -10000, sum[i][j] = 100000000000LL;
for (ll j = temp-500; j <= n*500; j++) {
dp[i][j] = dp[i-1][j-(temp-500)]+1, sum[i][j] = sum[i-1][j-(temp-500)] + p;
}
} else {
for (ll j = 0; j <= n*500; j++) {
dp[i][j] = dp[i-1][j], sum[i][j] = sum[i-1][j];
}
for (ll j = temp; j <= n*500; j++) {
if (dp[i][j] < dp[i-1][j-temp]) {
dp[i][j] = dp[i-1][j-temp];
sum[i][j] = sum[i-1][j-temp] + p;
} else if (dp[i][j] == dp[i-1][j-temp]) {
sum[i][j] = min(sum[i][j], sum[i-1][j-temp] + p);
}
}
for (ll j = 0; j <= n*500+temp-500; j++) {
if (dp[i][j] < dp[i-1][j-temp+500]+1) {
dp[i][j] = dp[i-1][j-temp+500]+1;
sum[i][j] = sum[i-1][j-temp+500] + p;
} else if (dp[i][j] == dp[i-1][j-temp+500]+1) {
sum[i][j] = min(sum[i][j], sum[i-1][j-temp+500] + p);
}
}
}
}
ll ans1 = 0, ans2 = 100000000000LL;
for (ll j = 0; j <= n*500; j++) {
if (ans1 < dp[n][j]) {
ans1 = dp[n][j];
ans2 = sum[n][j];
} else if (ans1 == dp[n][j]) {
ans2 = min(ans2, sum[n][j]);
}
}
printf("%lld %lld\n", ans1, ans2);
}
}
|
#include <iostream>
#include <algorithm>
#include <tuple>
using namespace std;
typedef pair<int,int> P; //500, -totalcost
P dp[101][50000];
int main(){
int n;
while(cin>>n,n){
fill(dp[0],dp[101],P(0,-5000000));
dp[0][0]=P(0,0);
for(int i=0;i<n;i++){
int price;
cin>>price;
for(int c=0;c<50000;c++){
if(dp[i][c].second<=-5000000) continue;
dp[i+1][c]=max(dp[i+1][c],dp[i][c]); //????????????
if(price%1000==0){
if(c>=500){
dp[i+1][c-500]=max(dp[i+1][c-500],P(dp[i][c].first+1,dp[i][c].second-price));
}
continue;
}else{
if(price%1000<=500){//500????????¨?????£???????¢???????
int cc= c + 1000 - price%1000 - 500;
dp[i+1][cc]=max(dp[i+1][cc],P(dp[i][c].first+1,dp[i][c].second-price));
}else{
if(price%1000-500<=c){
int cc = c - (price%1000-500);
//?°???????????????????500??????????¢???????
dp[i+1][cc]=max(dp[i+1][cc],P(dp[i][c].first+1,dp[i][c].second-price));
}
//500??????????¢??????????????°???????????¢???????
int cc = c + (1000-price%1000);
dp[i+1][cc]=max(dp[i+1][cc],P(dp[i][c].first,dp[i][c].second-price));
}
}
}
}
P ans = P(0,-5000000);
for(int c=0;c<50000;c++) if(dp[n][c].second>-5000000) ans = max(dp[n][c],ans);
cout<<ans.first<<' '<<-ans.second<<endl;
}
return 0;
} |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 100010
pair<int,int> dp[101][100000];
bool solve(){
int n, p;
scanf("%d", &n);
if(n == 0) return false;
for(int i=0;i<=n;i++){
for(int j=0;j<=n*499;j++){
dp[i][j] = {-INF, 0};
}
}
dp[0][0] = {0, 0};
for(int i=0;i<n;i++){
scanf("%d", &p);
int p2 = p;
p %= 1000;
for(int j=0;j<=i*499;j++){
//1000円のみ
dp[i+1][j + (1000-p)%500] = max(dp[i+1][j+(1000-p)%500],
{dp[i][j].first + (1 <= p && p <= 500), dp[i][j].second - p2});
//小銭で価格+500円払う
if(p + 500 <= j){
dp[i+1][j - (p+500)] = max(dp[i+1][j - (p+500)],
{dp[i][j].first + 1, dp[i][j].second - p2});
}
//札+小銭で価格+500円払う
if(p >= 501 && j >= p-500){
dp[i+1][j - (p-500)] = max(dp[i+1][j-(p-500)],
{dp[i][j].first + 1, dp[i][j].second - p2});
}
//買わない
dp[i+1][j] = max(dp[i+1][j], dp[i][j]);
}
}
pair<int,int> ans = {0, 0};
for(int i=0;i<=n*499;i++){
ans = max(ans, dp[n][i]);
}
printf("%d %d\n", ans.first, -ans.second);
return true;
}
int main(){
while(solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1 ; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1 ; } return 0; }
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e9+100;
const bool debug = 0;
/***************************************/
int N;
int p[100];
int dp[101][25001]; // 500円の枚数, 所持金(100円以下の小銭) = 最小購入金額
int main() {
while (cin >> N, N) {
REP(i, N) scanf("%d", p + i);
fill(dp[0], dp[N + 1], INF);
dp[0][0] = 0;
int lim[101] = {};
for (int i = N - 1; i >= 0; i--) {
int chg = (1000 - (p[i] % 1000)) % 1000;
if (chg >= 500) chg = 500;
lim[i] = 500 - chg + lim[i + 1];
}
REP(t, N) {
int chg = 1000 - (p[t] % 1000);
chg %= 1000;
for (int i = N; i >= 0; i--) {
for (int j = min(25000, lim[i] + 1000); j >= 0; j--) {
if (i) { // 購入して500円玉が増えた場合
if (chg >= 500) {
int cur = chg - 500; // 増加
if (j - cur >= 0 && dp[i - 1][j - cur] != INF) chmin(dp[i][j], dp[i - 1][j - cur] + p[t]);
}
else {
int cur = 500 - chg; // 減少
if (j + cur <= 25000 && dp[i - 1][j + cur] != INF) chmin(dp[i][j], dp[i - 1][j + cur] + p[t]);
}
}
// 購入して500円玉が増えなかった場合
if (chg < 500 && j - chg >= 0 && dp[i][j - chg] != INF) chmin(dp[i][j], dp[i][j - chg] + p[t]);
//小銭j円が多すぎて困ることはない
if (j) chmin(dp[i][j-1], dp[i][j]);
}
}
}
pii ans;
for (int i = N; i >= 0; i--) {
if (dp[i][0] == INF) continue;
ans = pii(i, dp[i][0]);
break;
}
if (debug) printf("@ ");
printf("%d %d\n", ans.fi, ans.se);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.