1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#include "cielib.h"
#include <vector>
#include <set>
using namespace std;

#define INF 2010000000

#define MAX_D 500

int V[MAX_D];
int P[MAX_D];

int d, r;


vector<int> v;
set<int> vs;
bool step(){

    for(int a=0; a<d; ++a){
        V[a] = P[a];
    }

    int left = 0;
    int right = INF;
    for(int a : v){
        right = min(right, r - P[a]);
    }
    --right;

    int ret = 0;

    while(left <= right){
        int m = (left + right) / 2;

        for(int a : v){
            V[a] = P[a] + m;
        }
        czyCieplo(V);

        for(int a : v){
            V[a] = P[a] + m + 1;
        }

        if(czyCieplo(V)){
            ret = m + 1;
            left = m + 1;
        }else{
            right = m - 1;
        }
    }
    if(ret == 0)return 0;
    for(int a : v){
        P[a] += ret;
    }
    return 1;
}

vector<int> pom;

bool check(int* first, int* last){
    if(first>=last)return 0;
    for(int* q=first; q<last; ++q){
        --V[*q];
    }
    czyCieplo(V);
    bool b = czyCieplo(P);
    for(int* q=first; q<last; ++q){
        ++V[*q];
    }
    return b;
}

void f(int* first, int* last){
    if(check(first, last)){
        if(first + 1 == last){
            v.push_back(*first);
            vs.insert(*first);
        }else{
            f(first, first + (last-first)/2);
            f(first + (last-first)/2, last);
        }
    }
}

int main(){
    d = podajD();
    r = podajR();

    for(int a=0; a<d; ++a){
        P[a] = 1;
    }
    while(1){
        for(int a=0; a<d; ++a){
            V[a] = P[a];
        }
        pom.clear();
        for(int a=0; a<d; ++a){
            if(vs.find(a) != vs.end())continue;

            pom.push_back(a);
        }
        f(pom.data(), pom.data() + pom.size());

        if(v.empty())break;
        if(!step())break;
        if(int(v.size()) == d)break;
    }

    if(int(v.size()) != d){
        for(int a=0; a<d; ++a){
            V[a] = P[a];
        }
        for(int a=0; a<d; ++a){
            bool qwe = 0;
            for(int b : v){
                if(a == b){
                    qwe = 1;
                    break;
                }
            }
            if(qwe)continue;

            if(P[a] == 1){
                V[a] = 2;
                czyCieplo(V);
                V[a] = 0;
                if(czyCieplo(V)){
                    P[a] = 0;
                }
                V[a] = 1;
            }
        }
        step();
    }


    znalazlem(P);

    return 0;
}