Messages posted by: longhi

Croatian Open Competition in Informatics - COCI 2020/2021
Internet online contest series

Over the next six months we will organize seven online contests as a warm-up for the 2021 season of high school programming competitions. Everyone is welcome to participate! Each contest will be three hours long and will feature five tasks. The contestants will also have full feedback with at most 50 submissions per task. The tasks will be of widely varying difficulty; we hope that many beginner or up-and-coming contestants will participate, as well as the more experienced ones.

The first contest will be held this Saturday, October 17, starting at 14:00 (GMT/UTC). Check out your local times at https://hsin.hr/coci/next_contest.html
You may use Python, Pascal, C/C++ or Java as your programming language of choice.
The contest will also be featured on a newly-developed judging system. If your students wish to get a bit more familiar with the system, we have uploaded the last 14 COCI seasons for them to practice on. Most problems (except for the very easy ones) have English translations.

The two relevant websites are:
https://hsin.hr/coci/ - information about the contest
https://evaluator.hsin.hr/ - judging system

We hope that you will join us or encourage your students to do so!
This is the fifteenth year in a row that we are hosting the COCI series. You can find the tasks (statements, test data and solutions) from the previous years at https://hsin.hr/coci/. There are over 600 original tasks for students to practice on!

With regards,
Kresimir Malnar
Croatian Computer Science Association

Treba da se dodadat natprevarite za 2020 godina, za da gi ima i na MENDO.

COCI 2019/2020
Internet online contest series
Direct link: http://hsin.hr/coci/

Over the next six months we will organize seven online contests as a warm-up for the 2020 season of high school programming competitions. Everyone is welcome to participate!
Each contest will be three hours long and will feature five tasks. The tasks will be of widely varying difficulty; we hope that many beginner or up-and-coming contestants will participate, as well as the more experienced ones.

The first contest will be held on Saturday, 19 October 2019, starting at 14:00 (GMT/UTC). You may use Python, Pascal, C/C++ or Java as your programming language of choice.

Instructions, problems and the contest system will be located at http://evaluator.hsin.hr

This web page will be available for registration 48 hours before the contest.
You can find problems, test data and solutions from previous Croatian competitions in informatics here: http://hsin.hr/coci/

BATIR wrote:Raboti na 6/20. Ne znam kade pravam greska. Kje mi pomogne nekoj?

Кога рагледуваш некое пиано, треба да одбереш едно негово поле (на пример, она кое е најлево и најдолу) и тоа да го користиш за означување на посетените локации во vis[][].

Инаку, замисли го овој пример:

Твоето решение нема да може воопшто да тргне надесно, бидејќи ги имаш означено сите 4 полиња кои се наоѓаат лево за посетени.
Еве го твојот код со споменатите поправки (сега работи на сите тест случаи):

#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
typedef pair<int,int> pi;
int n,m;
char mat[51][51];
bool vis[51][51];
vector<pair<int,int> > v1,v2,v3,e;
int di[4]={0,0,-1,1};
int dj[4]={1,-1,0,0};
 
bool valid_move(int i, int j)
{
    if(i<0 || i>=n || j<0 || j>=m || mat[i][j]=='#')return false; // dali e ok potegot
    return true;
}
 
bool to_the_end(vector<pi> v)
{
 
    for(int i=0; i<v.size(); i++)
    {
        if(v[i].first==e[i].first && v[i].second==e[i].second)continue; // dali stignav do F-s
        else return false;
    }
    return true;
}
int bfs(vector<pi> start,vector<pi> end)
{
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            vis[i][j]=false;
        }
    }
    queue<vector<pair<int,int> > > q;
    vector<pair<int,int> > v5;
    int min_first = 100000000, min_second = 100000000;
    for(pi curr :start)
    {
        int i=curr.first;
        int j=curr.second;  //mu pravi true na site od pocetniot klavir
        v5.push_back({i,j});
 
        min_first = min(min_first, curr.first);
        min_second = min(min_second, curr.second);
    }
 
    vis[min_first][min_second] = true;
     
    q.push(v5);
    queue<int> cekor;
    cekor.push(0);
    while(!q.empty())
    {
        vector<pi> v=q.front();
        q.pop();
        int c=cekor.front();
        cekor.pop();
 
        if(to_the_end(v))return c; // ako stignav do kraj
        for(int k=0; k<4; k++)
        {
            vector<pi> nov;
            int min_first = 100000000, min_second = 100000000;
            for(int z=0; z<v.size(); z++)
            {
                nov.push_back({v[z].first+di[k],v[z].second+dj[k]}); // go pomestuva cel objekt na nekoja nasoka
                min_first = min(min_first, v[z].first+di[k]);
                min_second = min(min_second, v[z].second+dj[k]);
            }
            bool can=true;
            for(int z=0; z<nov.size(); z++)
            {
                if(!valid_move(nov[z].first,nov[z].second)) // proveruva dali validna nasokata
                {
                    can=false;
                    break;
                }
            }
 
            bool flag = (vis[min_first][min_second]==true);
 
            if(can && !flag)
            {
                q.push(nov);
                cekor.push(c+1);
                for(int i=0; i<nov.size(); i++)
                {
                    vis[min_first][min_second]=true; // ako moze go zemam vektorot
                }
            }
        }
    }
    return -1;
 
}
int main()
{
    cin>>n>>m;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
 
            cin>>mat[i][j];
            if(mat[i][j]=='1')
            {
                v1.push_back({i,j});
            }
            else if(mat[i][j]=='2')
            {
                v2.push_back({i,j});
            }
            else if(mat[i][j]=='3')
            {
                v3.push_back({i,j});
            }
            else if(mat[i][j]=='F')
            {
                e.push_back({i,j});
            }
        }
    }
    vector<int> res;
    res.push_back(bfs(v1,e));
    if(v2.size()>0)res.push_back(bfs(v2,e)); else res.push_back(-1);
    if(v3.size()>0)res.push_back(bfs(v3,e)); else res.push_back(-1);
    int ret=1000000;
    int type=1;
    for(int i=0; i<res.size(); i++)
    {
        if(res[i]==0  || res[i]==-1)continue;
        if(res[i]<ret)
        {
            ret=res[i];
            type=i+1;
        }
    }
    if(ret==1000000)cout<<-1<<endl;
    else cout<<type<<endl<<ret<<endl;
    return 0;
}

MODDI wrote:Кодов ми работи на првите 8 случаеви, на останатите ми паѓа на време, како да го убрзам кодов?

Твојот алгоритам има преголема сложеност. Оваа задача може да се реши во линеарно време O(N). Така да, не може секогаш да се "убрза" некој почнат код, и треба да се внимава да направиме анализа на алгоритамот пред да почнеме да решаваме (за да не изгубиме време на пишување на решение кое нема да освои онолку поени колку што очекуваме, па да почнеме од почеток со куцање на нешто друго).

Е сега, во однос на задачата. Размисли дали можеме да пресметаме неколку работи однапред, за да не ги правиме при секоја ротација. Еве еден начин како може да се реши задачава со тој пристап:
Нека имаме низа frontSum[i] која што ни го памети збирот на првите i броеви - т.е. A[1] + A[2] + A[3] + ... + A[i].
Нека имаме низа backSum[i] која што ни го памети збирот на сите броеви од i-тиот до N-тиот - т.е. A[i] + A[i+1] + ... + A[N]
Нека имаме низа frontMin[i] која што го памети најмалиот збир од последователни броеви завршувајќи со i - т.е. min(A[1], A[1]+A[2], ... A[1] + A[2] + ... + A[i])
Нека имаме низа backMin[i] која што го памети најмалиот збир од последователни броеви почнувајќи со i - т.е. min(A[i], A[i]+A[i+1], A[i]+A[i+1]+A[i+2], ...)

Со овие низи, проверките се доста едноставни за секоја ротација. На пример, ако решиме да ја разгледуваме i-тата ротација (онаа која почнува со i-тиот број), треба само да провериме дали се исполнети овие два услови:
1) backMin[i] >= 0 (со ова го проверуваме потребниот услов за сите броеви од i-тиот до N-тиот, т.е. дали A[i] >= 0, дали A[i] + A[i+1] >= 0, итн)
2) backSum[i] + frontMin[i-1] >= 0 (ако ротацијата почнува од i-тиот елемент, тогаш таа по броевите A[i], A[i+1], ... A[N] ќе заврши со броевите A[1], A[2], А[i-1], па со овој чекор го проверуваме условот за тие следни броеви. Види како истиот е сличен на првиот, но додаваме backSum[i]).

За првата ротација не мора да го проверуваме вториот услов, бидејќи таму нема прелевање (т.е. броевите се A[1], A[2], ... A[N]). Еве и код ако уште не е јасно:

Scratcher wrote:Немам никаква друга идеја за решавање на оваа задача освен со рекурзија(backtracking)

Втората акција што може да ја направи роботот (две вреќи да се спојат во една) е многу поедноставна од првата (бидејќи таму треба да одлучуваме колку подароци да префрлиме).
Ова може да го средиме така што првата операција воопшто нема да ја правиме, туку ќе ја правиме само втората - но во две насоки, т.е. почнувајќи и од почетната состојба (како што се ќесите спакувани на почеток) и од крајната состојба (како што треба да бидат спакувани). Ова има логика бидејќи едната акција на роботот е слична на втората - само обратно - наместо да спојуваме две вреќи во една, делиме една вреќа на две.

Значи, можеме да напишеме програма која што ќе користи неколку идеи
1) Да пресметаме со колку акции може да се стигне од една состојба до сите други со спојување на вреќи (за тоа може да се искористи queue - слична идеја како кај алгоритамот BFS)
2) Ако од почетната состојба можеме да дојдеме до некоја состојба X, и од крајната состојба може да дојдеме до истата таа состојба X - тогаш може да се стигне од почетната состојба до крајната состојба. Притоа, ако требаат A чекори за да се стигне од почетната состојба до X, и B чекори за да се стигне од крајната состојба до X, тогаш за доаѓање од почетната до крајната состојба преку X требаат вкупно (A+B) чекори.

Ако е уште нејасно, еве решение

#include <bits/stdc++.h>
using namespace std;

void calculate(vector<int> state, map<vector<int>, int> &distances) {

queue<vector<int> > q;
    distances[state] = 0;
    q.push(state);

while (!q.empty()) {

vector<int> current = q.front();
        q.pop();

//do all possible merges
        for (int i=0; i<current.size(); i++) {
            for (int j=i+1; j<current.size(); j++) {

vector<int> next = current;
                next[i] += next[j];
                next.erase(next.begin() + j); //erase next[j]

sort(next.begin(), next.end());

if (distances.count(next) == 0) {
                    distances[next] = distances[current] + 1;
                    q.push(next);
                }
            }
        }
    }
}

int main() {

int N, sumStart = 0;
    cin >> N;

vector<int> start(N);
    for (int i=0; i<N; i++) {
        cin >> start[i];
        sumStart += start[i];
    }

int M, sumFinish = 0;
    cin >> M;

vector<int> finish(M);
    for (int i=0; i<M; i++) {
        cin >> finish[i];
        sumFinish += finish[i];
    }

sort(start.begin(), start.end());
    sort(finish.begin(), finish.end());

if (start == finish) {
        cout << 0 << endl;
        return 0;
    }

if (sumStart != sumFinish) {
        cout << -1 << endl;
        return 0;
    }

//calculate forward distance (merge from start)
    map<vector<int>, int> forwardDistance;
    calculate(start, forwardDistance);

//calculate backward distance (merge from finish)
    map<vector<int>, int> backwardDistance;
    calculate(finish, backwardDistance);

int result = -1;

for (auto move : forwardDistance) {
        vector<int> state = move.first;

if (backwardDistance.count(state) > 0) {
            int operations = forwardDistance[state] + backwardDistance[state];

if (result == -1 || result > operations) {
                result = operations;
            }
        }
    }

cout << result << endl;
    return 0;
}

BATIR wrote:Dali pod bitmaski, mislis za site kombinacii da gledame kolku sme potrosile, pri toa da e validno? I da go barame maksimumot?

Максимум градови во кои може да се направат митинзи - тоа што се бара во задачата.
Инаку, ако не ме разбра, тоа зборував дека "Постојат и други решенија за добивање на делумни поени" - едно е решението што беше напишано горе (greedy), може со bfs и битмаски (бидејќи има и помали тест случаи на кои се оценуваат решенијата), итн.

ThePopivanov wrote:Вчера на натпреварот кога ја решавав оваа падна на скоро сите тест примери освен на 3.
Денеска изменив нешто ситно сега на 23 поминува а само на 7 паѓа.

Ова е greedy решение и е доста логично, па ќе добие дел од поените (инаку, како што излезе, сите ќе имаа 0 на таа задача).
Но, оваа задача е најдобро да се решава со помош на динамичко програмирање.

Идејата е доста едноставна, ќе користиме матрица dp[c][n] која ќе ни памети во колку најмногу градови може да се направи митинг ако веќе сме разгледале [c] градови и имаме уште [n] средства на располагање.
Сега, ќе ги поминуваме градовите еден по еден и ќе ја пополнуваме матрицава (како и други слични задачи кои се решаваат на ваков начин) и истата ќе содржи некаков резултат.
Но, по кој редослед да ги поминуваме градовите? Од кога ќе ни текне дека единствениот начин да добиеме пари е од организацијата на митинг (инаку само трошиме), тогаш може да забележиме дека е најдобро да ги сортираме во опаѓачки редослед според R[x]. За се друго ќе се погрижи динамичкото програмирање. И тоа е решението.

(Постојат и други решенија за добивање на делумни поени, dfs, битмаски, итн)

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
 
int main()
{
    int N, C;
    cin >> N >> C;

vector<pair<int, int> > cities(C);
    for (int i=0; i<C; i++) {
        cin >> cities[i].second >> cities[i].first;
    }

sort(cities.begin(), cities.end());
    reverse(cities.begin(), cities.end());

int dp[C+1][N+1];
    memset(dp, 0, sizeof(dp));

int result = 0;

for (int m=0; m<C; m++) {
        int cost = cities[m].second, back = cities[m].first;

for (int fromCost=N; fromCost >= 0; fromCost--) {

//da ne se pravi miting vo gradot (m)
            dp[m+1][fromCost] = max(dp[m+1][fromCost], dp[m][fromCost]);

//da se pravi miting vo gradot (m)
            if (fromCost >= cost) { //mora da imame dovolno sredstva
                int toCost = fromCost - cost + back;

dp[m + 1][toCost] = max(dp[m + 1][toCost], dp[m][fromCost] + 1);
                result = max(result, dp[m + 1][toCost]);
            }
        }
    }

cout << result;
    return 0;
}

forelax wrote:Фала, разбрав А и ги погледнав тестовите, random ми изгледаат. Инаку твоето решение има многу повеќе смисла

Мора да се прават од некој граф (добро, со некоја random должина на ребра - ама тоа и не е толку важно), и потоа да се направи матрицата, инаку голем број од резултатите ќе биде "GRESHKA".
Можеби да се додадат некои примери со слични должини, ама тоа е тешко да се погоди оти различни решенија ќе се искуцаат од натпреварувачите. Според резултатите на натпреварот, мислам дека се океј.

forelax wrote:Не очекував решението да работи. Како ефективната временска комплексност не стига до n^4 (бидејќи не добивам надминат временски лимит)? Дали е тоа до лоши тестови?
Еден пример би било кога матрицата на влез ќе е целосно исполнета со единици (освен на дијагоналата). Тогаш што би било поефикасно решение?

Немам време да го разгледам подетално твоето решение, но колку што дискутиравме денес дел од оценувањето е намерно (greedy на четвртата носи дел од поените, тука, итн), за да нема огромен скок во тежината и дека е регионален натпревар (и секако голем број ќе продолжат на државен натпревар).

Инаку, постои доста едноставно решение на задачава, кое отприлика оди вака:

#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    int n;
    cin >> n;

int dist[301][301];

for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            cin >> dist[i][j];
        }
    }

for (int i=0; i<n; i++) {
        for (int j=i+1; j<n; j++) {
            for (int k=0; k<n; k++) {

if (k!=i && k!=j && dist[i][k] + dist[k][j] < dist[i][j]) {
                    cout << "GRESHKA" << endl;
                    return 0;
                }
            }
        }
    }

long long sum = 0;
    for (int i=0; i<n; i++) {
        for (int j=i+1; j<n; j++) {

bool important = true;
            for (int k=0; k<n && important; k++) {

if (k!=i && k!=j && dist[i][k] + dist[k][j] == dist[i][j]) {
                    //nema potreba od vakvo rebro
                    important = false;
                }
            }

if (important) {
                sum += dist[i][j];
            }
        }
    }
 
    cout << sum << endl;
    return 0;
}

floreloriz123 wrote:http://mendo.mk/Task.do?id=704

Знае ли некој зошто не ми поминува на 1/10 тест случаи (на 4тиот мојот код дава резултат 1 23, а треба 1 21)?

Ај види го следниот код (таму каде што е поправено) и размисли зошто овој работи на сите примери.
Хинт: И зошто тоа има врска со ова "Цревата на системот не може да поминат преку полињата со бетонски плочи, но слободно може да поминуваат преку сите други полиња.", и фактот што долу за секое 'C' викаш graph[i][j] = 0; visited[i][j] = true;

P.S. Пробав да променам најмалку работи во кодот, па затоа само сменив во функцијата bfs(), инаку ова може да се поедностави.

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <queue>
#include <list>
#include <stack>
#include <string>
#include <sstream>
#include <iomanip>
#include <map>
#include <climits>
#include <cfloat>
#include <cstdlib>

#define pb push_back

using namespace std;

const int MAXN = 101;
const int MAXV = 1000000000;

int rows, cols, power, M = 0;
vector <vector <int> > graph(MAXN*10, vector <int> (MAXN*10));

struct state {
    int x, y;
};

bool validMove(state next) {
    return (next.x >= 0 && next.x < rows && next.y >= 0 && next.y < cols &&
            graph[next.x][next.y] != -1);
}

vector <state> possibleMoves(state node) {
    vector <state> moves;
    moves.pb({node.x, node.y-1});
    moves.pb({node.x, node.y+1});
    moves.pb({node.x-1, node.y});
    moves.pb({node.x+1, node.y});
    return moves;
}

bool bfs(state s, vector <vector <bool> > &visited, vector <vector <int> > &nGraph) {
    queue <state> q;
    q.push(s);
    
    //dodadeno
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            visited[i][j] = false;
            
            if (nGraph[i][j] != -1) {
                nGraph[i][j] = MAXV;
            }
        }
    }

nGraph[s.x][s.y] = 0;
    visited[s.x][s.y] = true;

while (!q.empty()) {
        auto node = q.front();
        q.pop();
        vector <state> moves = possibleMoves(node);

for (auto next : moves) {
            if (validMove(next)) {
                if (!visited[next.x][next.y]) {
                    visited[next.x][next.y] = true;
                    if (nGraph[next.x][next.y] > nGraph[node.x][node.y] + 1) {
                        nGraph[next.x][next.y] = nGraph[node.x][node.y] + 1;
                        if (nGraph[next.x][next.y] <= power) {
                            q.push(next);
                            graph[next.x][next.y]++;
                            M = max(M, graph[next.x][next.y]);
                        }
                    }
                }
            }
        }
    }
}

int main() {
    cin >> rows >> cols >> power;

queue <state> q;
    vector <vector <bool> > visited(MAXN*10, vector <bool> (MAXN*10, false));
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            char c;
            cin >> c;
            if (c == '#') graph[i][j] = -1;
            else if (c == 'C') {
                graph[i][j] = 0;
                q.push({i, j});
                visited[i][j] = true;
            }
            else graph[i][j] = MAXV;
        }
    }

vector <vector <int> > nGraph = graph;
    graph = vector <vector <int> > (MAXN*10, vector <int> (MAXN*10, 0));

while (!q.empty()) {
        state s = q.front();
        q.pop();
        bfs(s, visited, nGraph);
    }

for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
//            cout << graph[i][j] << " ";
            if (graph[i][j] == M) {
                cout << i+1 << " " << j+1;
                return 0;
            }
        }
//        cout << endl;
    }

return 0;
}

MODDI wrote:Ја решавав задачава, кодов ми работи на 6 тест примери, на останатите ми враќа прогрешен резултат, хелп

Има повеќе работи за поправање. Види кодот подолу:

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
using namespace std;
vector<string>registered;
vector<int> indexes;
 
bool check(string one, string two)
{
    string one_letters = "";
    for (int i=0; i<one.size(); i++) {
        if (one[i] >= 'a' && one[i] <= 'z') {
            one_letters += one[i];
        }
    }
 
    string two_letters = "";
    for (int i=0; i<two.size(); i++) {
        if (two[i] >= 'a' && two[i] <= 'z') {
            two_letters += two[i];
        }
    }
 
    return (one_letters == two_letters);
}
 
void split_string(string inserted_name)
{
    for(int i=0;i<registered.size();i++)
    {
        int numbers=0;
        int index=pow(10,registered[i].size()-inserted_name.size()) / 10;
        string pom=registered[i];
 
        for(int j=inserted_name.size(); j < pom.size();j++)
        {
            if(pom[j]>='0' && pom[j]<='9')
            {
                numbers += (int(pom[j]-'0'))*index;
                index /= 10;
            }
        }
         
        if(check(pom,inserted_name)==true)
            indexes.push_back(numbers);
    }
}
int main()
{
    string inserted_name;
    cin>>inserted_name;
    int size;
    cin>>size;
 
    for(int i=0;i<size;i++)
    {
        string a;
        cin>>a;
        registered.push_back(a);
    }
    split_string(inserted_name);
    sort(indexes.begin(),indexes.end());
 
    if (indexes.size() == 0 || indexes[0] != 0) {
        cout <<inserted_name << endl;
        return 0;
    }
 
    for(int i=0;i<indexes.size();i++)
    {
        if(indexes[i]+1!=indexes[i+1])
        {
            cout<<inserted_name<<indexes[i]+1<<endl;
            return 0;
        }
    }
 
    cout<<inserted_name<<endl;
    return 0;
 
}

David_Gorgiev wrote:Овој код е за задачата „Точка“ од Научи С++
Може ли некој да ми каже што имам грешка во кодот?

Прво, не мора да проверуваш (како со првиот if) дали податоците се соодветни (ако пишува во текстот дека ќе бидат помеѓу 0 и 1000, на пример, тогаш ќе бидат).
Второ, можеш да симнеш тест случај од МЕНДО и да го извршиш на компјутер за да видиш што е проблемот.

Еве што забележав јас:
1) каде што имаш (by=dx+b) треба наместо dx да е dy.
2) каде што имаш (ax=px+a) треба да имаш само (ax=px), инаку A и B ти се истата точка (види кај B дека користиш dx,dy).

Со тие промени работи на сите тест случаи.

#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
    int ax,ay,bx,by,px,py,dx,dy;
    int a,b;
    int tx,ty;
    int A,B,C,D;
    cin>>px>>py>>a>>b;
    cin>>tx>>ty;
    if(px>=0 && px<=1000 && py>=0 && py<=1000 && a>=1 && a<=1000 && b>=1 && b<=1000 && tx>=0 && ty<=1000)
    {
        // tocka D
        dx=px+a;
        dy=py;
        // tocka B
        bx=dx;
        by=dy+b;
        // tocka A
        ax=px;
        ay=py+b;
        // uslovi za tockata T
        // ako lezi na tocka A
        if(tx==ax && ty==ay) 
        {
        cout<<"strana"<<endl;
        goto kraj;
    }
        // ako lezi na strana AB
        if(tx>=ax && tx<=bx && ty==ay) 
        {
        cout<<"strana"<<endl;
        goto kraj;
    }
        // ako lezi na tocka B
        if(tx==bx && ty==by) 
        {
        cout<<"strana"<<endl;
        goto kraj;
    }
        // ako lezi na strana BD
        if(ty<=by && ty>=dy && tx==bx) 
        {
        cout<<"strana"<<endl;
        goto kraj;
    }
        // ako lezi na tocka D
        if(tx==dx && ty==dy) 
        {
        cout<<"strana"<<endl;
        goto kraj;
    }
        // ako lezi na strana DC
        if(tx<=dx && tx>=px && ty==dy) 
        {
        cout<<"strana"<<endl;
        goto kraj;
    }
        // ako lezi na tocka C
        if(tx==px && ty==py) 
        {
        cout<<"strana"<<endl;
        goto kraj;
    }
        // ako lezi na strana CA
        if(ty>=py && ty<=ay && tx==ax) 
        {
        cout<<"strana"<<endl;
        goto kraj;
    }
        if(tx>=px && tx<=bx && ty>=py && ty<=by)
        {
        cout<<"vnatre"<<endl;
        goto kraj;
    }
       else
       {
       cout<<"nadvor"<<endl;
       goto kraj;
    }
    }
    kraj:
    return 0;
}

>

MODDI wrote:Ја решавав задачата Зајак од МОИ 2015, ми работи на 3/25 , помош околу кодов.

Не е баш така, кодов како да е за некоја друга задача.
Јас вака би поправил, имаш коментари во програмата ако нешто не е јасно.

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    int N,M;
    cin>>N>>M;
    int MAT[N][M];
    for(int i=0;i<N;i++)
    {
        for(int j=0;j<M;j++)
        {
            cin>>MAT[i][j];
        }
    }

int dp[N][M];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = MAT[0][0];

for (int j=1; j < M; j++) {
        //vo vtoriot red mozheme da dojdeme taka shto kje
        //pochneme od [0][0] pa skokame do nekoe pole vo istiot
        //red, pa potoa edna kolona nadolu
        dp[1][j] = MAT[0][0] + MAT[0][j] + MAT[1][j];
    }

//za sekoj nareden red

for (int i=1; i+1 < N; i++) {
        //najdi gi dvata najgolemi elementi vo ovaa redica
        int max1 = 0, max2 = 0;
        for (int j=0; j<M; j++) {
            if (dp[i][j] >= max1) {
                max2 = max1;
                max1 = dp[i][j];
            } else if (dp[i][j] > max2) {
                max2 = dp[i][j];
            }
        }

for (int j=0; j<M; j++) {
            //najdobro e da skokneme od najgolemiot element vo redicata
            //do ova pole, pa potoa eden chekor nadolu
            int max_value = max1;
            if (dp[i][j] == max1) {
                //ne mozheme da skokneme na istoto pole, zemi go vtoriot maximum
                max_value = max2;
            }

dp[i+1][j] = max(dp[i+1][j], max_value + MAT[i][j] + MAT[i+1][j]);
        }
    }

//vo posledniot red mozheme da skokneme do poslednata kolona
    for (int j=0; j+1 < M; j++) {
        dp[N-1][M-1] = max(dp[N-1][M-1], dp[N-1][j] + MAT[N-1][M-1]);
    }

cout<<dp[N-1][M-1]<<endl;
    return 0;
}

MODDI wrote:Ја решавав задачава и ми вади 8/40, може малку помош околу кодов.

Имаш точно решение погоре ако бараш нова идеја.

Инаку, околу кодов, би ти препорачал да почнеш од почеток оти мислам дека малку се имаш измешано со even, noneven и како се тоа го користиш.
На пример, додади го делот што го имам ставено под коментар во твојата програма, и на пример изврши ја кај тебе на компјутер (за пример од текстот на задачата), ќе видиш печати "error", а во тој дел pom треба да е помало од even.size(), бидејќи низата е дефинирана вака: visited_even[even.size()]