output
stringlengths 52
181k
| instruction
stringlengths 296
182k
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a[51][51];
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
void brace(int i, int j) { cout << '(' << i << ',' << j << ')' << ' '; }
int main() {
memset(a, -1, sizeof a);
int n, m, K;
cin >> n >> m >> K;
queue<pair<int, int> > q;
a[1][1] = 1;
q.push(make_pair(1, 1));
int cnt = 1;
while (!q.empty() && cnt < K) {
pair<int, int> h = q.front();
q.pop();
for (int k = 0; k < 4; k++) {
int ni = dx[k] + h.first;
int nj = dy[k] + h.second;
if (ni >= 1 && ni <= n && nj >= 1 && nj <= m && a[ni][nj] == -1) {
a[ni][nj] = a[h.first][h.second] + 1;
q.push(make_pair(ni, nj));
++cnt;
if (cnt == K) break;
}
}
}
int tot = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] >= 0) {
tot += a[i][j];
}
}
}
cout << tot << '\n';
for (;;) {
int max_val = -1;
int ci = -1, cj = -1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] > max_val) {
max_val = a[i][j];
ci = i, cj = j;
}
}
}
if (max_val == -1) break;
int mi = 1, mj = 1;
brace(mi, mj);
while (mi < ci) {
++mi;
brace(mi, mj);
}
while (mj < cj) {
++mj;
brace(mi, mj);
}
a[ci][cj] = -1;
cout << '\n';
}
return 0;
}
|
### Prompt
In cpp, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[51][51];
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
void brace(int i, int j) { cout << '(' << i << ',' << j << ')' << ' '; }
int main() {
memset(a, -1, sizeof a);
int n, m, K;
cin >> n >> m >> K;
queue<pair<int, int> > q;
a[1][1] = 1;
q.push(make_pair(1, 1));
int cnt = 1;
while (!q.empty() && cnt < K) {
pair<int, int> h = q.front();
q.pop();
for (int k = 0; k < 4; k++) {
int ni = dx[k] + h.first;
int nj = dy[k] + h.second;
if (ni >= 1 && ni <= n && nj >= 1 && nj <= m && a[ni][nj] == -1) {
a[ni][nj] = a[h.first][h.second] + 1;
q.push(make_pair(ni, nj));
++cnt;
if (cnt == K) break;
}
}
}
int tot = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] >= 0) {
tot += a[i][j];
}
}
}
cout << tot << '\n';
for (;;) {
int max_val = -1;
int ci = -1, cj = -1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] > max_val) {
max_val = a[i][j];
ci = i, cj = j;
}
}
}
if (max_val == -1) break;
int mi = 1, mj = 1;
brace(mi, mj);
while (mi < ci) {
++mi;
brace(mi, mj);
}
while (mj < cj) {
++mj;
brace(mi, mj);
}
a[ci][cj] = -1;
cout << '\n';
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 60;
int n, m, k;
int penalty = 0;
vector<vector<pair<int, int> > > moves;
vector<pair<int, int> > dist[MAXN * 2];
void print(pair<int, int> p) {
cout << "(" << p.first << "," << p.second << ")";
}
void print(vector<pair<int, int> > v) {
int sz = (int)v.size();
for (int i = 0; i < sz; i++) {
print(v[i]);
cout << " \n"[i == sz - 1];
}
}
void path(int a, int b) {
vector<pair<int, int> > v;
for (int i = 1; i <= a; i++) {
v.push_back(pair<int, int>(i, 1));
}
for (int j = 2; j <= b; j++) {
v.push_back(pair<int, int>(a, j));
}
penalty += v.size();
moves.push_back(v);
}
int main(void) {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dist[i + j - 1].push_back(pair<int, int>(i, j));
}
}
for (int i = 1; i < n + m; i++) sort(dist[i].begin(), dist[i].end());
int ind = 1, ind2 = (int)dist[1].size() - 1;
while (k--) {
path(dist[ind][ind2].first, dist[ind][ind2].second);
ind2--;
if (ind2 < 0) {
ind++;
ind2 = (int)dist[ind].size() - 1;
}
}
cout << penalty << "\n";
for (int i = (int)moves.size() - 1; i >= 0; i--) print(moves[i]);
return 0;
}
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 60;
int n, m, k;
int penalty = 0;
vector<vector<pair<int, int> > > moves;
vector<pair<int, int> > dist[MAXN * 2];
void print(pair<int, int> p) {
cout << "(" << p.first << "," << p.second << ")";
}
void print(vector<pair<int, int> > v) {
int sz = (int)v.size();
for (int i = 0; i < sz; i++) {
print(v[i]);
cout << " \n"[i == sz - 1];
}
}
void path(int a, int b) {
vector<pair<int, int> > v;
for (int i = 1; i <= a; i++) {
v.push_back(pair<int, int>(i, 1));
}
for (int j = 2; j <= b; j++) {
v.push_back(pair<int, int>(a, j));
}
penalty += v.size();
moves.push_back(v);
}
int main(void) {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dist[i + j - 1].push_back(pair<int, int>(i, j));
}
}
for (int i = 1; i < n + m; i++) sort(dist[i].begin(), dist[i].end());
int ind = 1, ind2 = (int)dist[1].size() - 1;
while (k--) {
path(dist[ind][ind2].first, dist[ind][ind2].second);
ind2--;
if (ind2 < 0) {
ind++;
ind2 = (int)dist[ind].size() - 1;
}
}
cout << penalty << "\n";
for (int i = (int)moves.size() - 1; i >= 0; i--) print(moves[i]);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > sweet;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
pair<int, int> Trace[55][55];
int d[55][55];
int m, n, k;
bool inside(int i, int j) { return (i >= 1 && i <= n && j >= 1 && j <= m); }
void solve() {
queue<pair<int, int> > qq;
bool visited[55][55];
memset(visited, 0, sizeof visited);
int ct = 0;
pair<int, int> tmp;
tmp.first = 1;
tmp.second = 1;
d[1][1] = 1;
visited[1][1] = true;
qq.push(tmp);
int i;
while (ct < k) {
ct++;
tmp = qq.front();
sweet.push_back(tmp);
qq.pop();
int tmpx, tmpy;
for (i = 0; i < 4; i++) {
tmpx = tmp.first + dx[i];
tmpy = tmp.second + dy[i];
if (inside(tmpx, tmpy) && !visited[tmpx][tmpy]) {
d[tmpx][tmpy] = d[tmp.first][tmp.second] + 1;
Trace[tmpx][tmpy].first = tmp.first;
Trace[tmpx][tmpy].second = tmp.second;
visited[tmpx][tmpy] = true;
qq.push(make_pair(tmpx, tmpy));
}
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
solve();
int i, j;
int ans = 0;
for (i = 0; i < k; i++) ans += d[sweet[i].first][sweet[i].second];
printf("%d\n", ans);
for (i = k - 1; i >= 0; i--) {
vector<pair<int, int> > res;
int x, y;
x = sweet[i].first;
y = sweet[i].second;
for (j = 1; j <= d[sweet[i].first][sweet[i].second] - 1; j++) {
res.push_back(make_pair(x, y));
x = Trace[x][y].first;
y = Trace[x][y].second;
}
printf("(1,1)");
for (j = res.size() - 1; j >= 0; j--) {
printf(" (%d,%d)", res[j].first, res[j].second);
}
printf("\n");
}
}
|
### Prompt
Develop a solution in CPP to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > sweet;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
pair<int, int> Trace[55][55];
int d[55][55];
int m, n, k;
bool inside(int i, int j) { return (i >= 1 && i <= n && j >= 1 && j <= m); }
void solve() {
queue<pair<int, int> > qq;
bool visited[55][55];
memset(visited, 0, sizeof visited);
int ct = 0;
pair<int, int> tmp;
tmp.first = 1;
tmp.second = 1;
d[1][1] = 1;
visited[1][1] = true;
qq.push(tmp);
int i;
while (ct < k) {
ct++;
tmp = qq.front();
sweet.push_back(tmp);
qq.pop();
int tmpx, tmpy;
for (i = 0; i < 4; i++) {
tmpx = tmp.first + dx[i];
tmpy = tmp.second + dy[i];
if (inside(tmpx, tmpy) && !visited[tmpx][tmpy]) {
d[tmpx][tmpy] = d[tmp.first][tmp.second] + 1;
Trace[tmpx][tmpy].first = tmp.first;
Trace[tmpx][tmpy].second = tmp.second;
visited[tmpx][tmpy] = true;
qq.push(make_pair(tmpx, tmpy));
}
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
solve();
int i, j;
int ans = 0;
for (i = 0; i < k; i++) ans += d[sweet[i].first][sweet[i].second];
printf("%d\n", ans);
for (i = k - 1; i >= 0; i--) {
vector<pair<int, int> > res;
int x, y;
x = sweet[i].first;
y = sweet[i].second;
for (j = 1; j <= d[sweet[i].first][sweet[i].second] - 1; j++) {
res.push_back(make_pair(x, y));
x = Trace[x][y].first;
y = Trace[x][y].second;
}
printf("(1,1)");
for (j = res.size() - 1; j >= 0; j--) {
printf(" (%d,%d)", res[j].first, res[j].second);
}
printf("\n");
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
point p[2530];
bool cmp(point a, point b) { return a.x + a.y < b.x + b.y; }
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int num = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
p[num].x = i;
p[num].y = j;
num++;
}
sort(p, p + num, cmp);
int ans = 0;
for (int i = k - 1; i >= 0; i--) {
ans += p[i].x + p[i].y - 1;
}
printf("%d\n", ans);
for (int i = k - 1; i >= 0; i--) {
for (int a = 1; a <= p[i].x; a++) printf("(%d,1) ", a);
for (int a = 2; a <= p[i].y; a++) printf("(%d,%d) ", p[i].x, a);
printf("\n");
}
return 0;
}
|
### Prompt
Generate a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
point p[2530];
bool cmp(point a, point b) { return a.x + a.y < b.x + b.y; }
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int num = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
p[num].x = i;
p[num].y = j;
num++;
}
sort(p, p + num, cmp);
int ans = 0;
for (int i = k - 1; i >= 0; i--) {
ans += p[i].x + p[i].y - 1;
}
printf("%d\n", ans);
for (int i = k - 1; i >= 0; i--) {
for (int a = 1; a <= p[i].x; a++) printf("(%d,1) ", a);
for (int a = 2; a <= p[i].y; a++) printf("(%d,%d) ", p[i].x, a);
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
int IntMaxVal = (int)1e20;
int IntMinVal = (int)-1e20;
long long LongMaxVal = (long long)1e20;
long long LongMinVal = (long long)-1e20;
template <typename T>
inline void minimize(T& a, T b) {
a = std::min(a, b);
}
template <typename T>
inline void maximize(T& a, T b) {
a = std::max(a, b);
}
using namespace std;
template <typename T>
struct argument_type;
template <typename T, typename U>
struct argument_type<T(U)> {};
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& s) {
is >> s.first >> s.second;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) os << v[i] << ' ';
os << '\n';
return os;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& s, pair<T1, T2>& t) {
s << t.first << ' ' << t.second;
return s;
}
template <typename T>
vector<T> readVector(int n) {
vector<T> res(n);
for (int i = 0; i < n; i++) cin >> res[i];
return res;
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
;
int m;
cin >> m;
;
int k;
cin >> k;
;
vector<pair<int, int> > points;
int dist = 0;
for (int d = 0; d < n + m - 1; ++d)
for (int j = 0; j < m; ++j) {
int i = d - j;
if (i < 0 || i >= n) continue;
if (j < 0 || j >= m) continue;
if (points.size() < k) {
points.push_back(make_pair(i + 1, j + 1));
dist += d + 1;
}
}
cout << dist << '\n';
for (int i = k - 1; i >= 0; --i) {
int y = points[i].first;
int x = points[i].second;
cout << "(1, 1)";
for (int i = 2; i < y + 1; ++i) cout << " (" << i << ", 1)";
for (int i = 2; i < x + 1; ++i) cout << " (" << y << ", " << i << ")";
cout << '\n';
}
}
|
### Prompt
Your task is to create a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
int IntMaxVal = (int)1e20;
int IntMinVal = (int)-1e20;
long long LongMaxVal = (long long)1e20;
long long LongMinVal = (long long)-1e20;
template <typename T>
inline void minimize(T& a, T b) {
a = std::min(a, b);
}
template <typename T>
inline void maximize(T& a, T b) {
a = std::max(a, b);
}
using namespace std;
template <typename T>
struct argument_type;
template <typename T, typename U>
struct argument_type<T(U)> {};
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& s) {
is >> s.first >> s.second;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) os << v[i] << ' ';
os << '\n';
return os;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& s, pair<T1, T2>& t) {
s << t.first << ' ' << t.second;
return s;
}
template <typename T>
vector<T> readVector(int n) {
vector<T> res(n);
for (int i = 0; i < n; i++) cin >> res[i];
return res;
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
;
int m;
cin >> m;
;
int k;
cin >> k;
;
vector<pair<int, int> > points;
int dist = 0;
for (int d = 0; d < n + m - 1; ++d)
for (int j = 0; j < m; ++j) {
int i = d - j;
if (i < 0 || i >= n) continue;
if (j < 0 || j >= m) continue;
if (points.size() < k) {
points.push_back(make_pair(i + 1, j + 1));
dist += d + 1;
}
}
cout << dist << '\n';
for (int i = k - 1; i >= 0; --i) {
int y = points[i].first;
int x = points[i].second;
cout << "(1, 1)";
for (int i = 2; i < y + 1; ++i) cout << " (" << i << ", 1)";
for (int i = 2; i < x + 1; ++i) cout << " (" << y << ", " << i << ")";
cout << '\n';
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int used[52][52];
vector<vector<pair<int, int> > > ans;
vector<pair<int, int> > make_root(int x, int y) {
vector<pair<int, int> > ret;
ret.push_back(pair<int, int>(x, y));
while (x) ret.push_back(pair<int, int>(--x, y));
while (y) ret.push_back(pair<int, int>(x, --y));
reverse(ret.begin(), ret.end());
return ret;
}
int solve() {
int cost = 0;
for (int i = 0; i < (int)(105); i++) {
for (int j = 0; j < (int)(i + 1); j++) {
if (j < m && i - j < n && 0 <= i - j && 0 <= j && !used[j][i - j]) {
ans.push_back(make_root(i - j, j));
cost += i + 1;
if (--k == 0) return cost;
}
}
}
return cost;
}
int main() {
int i, j;
cin >> n >> m >> k;
cout << solve() << endl;
reverse(ans.begin(), ans.end());
for (int i = 0; i < (int)(ans.size()); i++)
for (int j = 0; j < (int)(ans[i].size()); j++)
printf("(%d,%d)%s", ans[i][j].first + 1, ans[i][j].second + 1,
j + 1 == ans[i].size() ? "\n" : " ");
return 0;
}
|
### Prompt
Please formulate a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int used[52][52];
vector<vector<pair<int, int> > > ans;
vector<pair<int, int> > make_root(int x, int y) {
vector<pair<int, int> > ret;
ret.push_back(pair<int, int>(x, y));
while (x) ret.push_back(pair<int, int>(--x, y));
while (y) ret.push_back(pair<int, int>(x, --y));
reverse(ret.begin(), ret.end());
return ret;
}
int solve() {
int cost = 0;
for (int i = 0; i < (int)(105); i++) {
for (int j = 0; j < (int)(i + 1); j++) {
if (j < m && i - j < n && 0 <= i - j && 0 <= j && !used[j][i - j]) {
ans.push_back(make_root(i - j, j));
cost += i + 1;
if (--k == 0) return cost;
}
}
}
return cost;
}
int main() {
int i, j;
cin >> n >> m >> k;
cout << solve() << endl;
reverse(ans.begin(), ans.end());
for (int i = 0; i < (int)(ans.size()); i++)
for (int j = 0; j < (int)(ans[i].size()); j++)
printf("(%d,%d)%s", ans[i][j].first + 1, ans[i][j].second + 1,
j + 1 == ans[i].size() ? "\n" : " ");
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int num[100][100], mark[100][100], mark1[100][100];
int main() {
int n, m, i, j, k, ans, x, y, l, j1, i1;
for (i = 1; i < 100; i++) {
for (j = 1; j < 100; j++) {
num[i][j] = i + j - 1;
}
}
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
memset(mark, 0, sizeof(mark));
i = 1;
int ind = 1;
ans = 0;
while (ind <= k) {
for (i1 = 1; i1 <= n && ind <= k; i1++) {
for (j = 1; j <= m && ind <= k; j++) {
if (num[i1][j] == i) {
mark[i1][j] = ind++;
ans += i1 + j - 1;
}
}
}
i++;
}
printf("%d\n", ans);
ind = k;
while (ind >= 1) {
for (i1 = 1; i1 <= n && ind >= 1; i1++) {
for (j = 1; j <= m && ind >= 1; j++) {
if (mark[i1][j] == ind) {
ind--;
for (j1 = 1; j1 <= j; j1++) printf("(1,%d) ", j1);
for (l = 2; l <= i1; l++) printf("(%d,%d) ", l, j);
printf("\n");
}
}
}
}
}
return 0;
}
|
### Prompt
Please create a solution in CPP to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int num[100][100], mark[100][100], mark1[100][100];
int main() {
int n, m, i, j, k, ans, x, y, l, j1, i1;
for (i = 1; i < 100; i++) {
for (j = 1; j < 100; j++) {
num[i][j] = i + j - 1;
}
}
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
memset(mark, 0, sizeof(mark));
i = 1;
int ind = 1;
ans = 0;
while (ind <= k) {
for (i1 = 1; i1 <= n && ind <= k; i1++) {
for (j = 1; j <= m && ind <= k; j++) {
if (num[i1][j] == i) {
mark[i1][j] = ind++;
ans += i1 + j - 1;
}
}
}
i++;
}
printf("%d\n", ans);
ind = k;
while (ind >= 1) {
for (i1 = 1; i1 <= n && ind >= 1; i1++) {
for (j = 1; j <= m && ind >= 1; j++) {
if (mark[i1][j] == ind) {
ind--;
for (j1 = 1; j1 <= j; j1++) printf("(1,%d) ", j1);
for (l = 2; l <= i1; l++) printf("(%d,%d) ", l, j);
printf("\n");
}
}
}
}
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct II {
int ST, ND;
II(int a = 0, int b = 0) : ST(a), ND(b) {}
bool operator<(const II& op) const {
if (ST + ND != op.ST + op.ND) return ST + ND < op.ST + op.ND;
return ST > op.ST;
}
};
vector<II> g;
void print(int r, int c) {
bool pr = false;
for (int j = 1; j <= c; j++) {
printf("%s(%d,%d)", pr ? " " : "", 1, j);
pr = true;
}
for (int i = 2; i <= r; i++) {
printf("%s(%d,%d)", pr ? " " : "", i, c);
pr = true;
}
printf("\n");
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) g.push_back(II(i, j));
sort(g.begin(), g.end());
int ans = 0;
for (int i = 0; i < k; ++i) ans += g[i].ST + g[i].ND - 1;
printf("%d\n", ans);
int dem = 0;
for (int i = k - 1; i >= 0; --i) {
print(g[i].ST, g[i].ND);
}
return 0;
}
|
### Prompt
Generate a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct II {
int ST, ND;
II(int a = 0, int b = 0) : ST(a), ND(b) {}
bool operator<(const II& op) const {
if (ST + ND != op.ST + op.ND) return ST + ND < op.ST + op.ND;
return ST > op.ST;
}
};
vector<II> g;
void print(int r, int c) {
bool pr = false;
for (int j = 1; j <= c; j++) {
printf("%s(%d,%d)", pr ? " " : "", 1, j);
pr = true;
}
for (int i = 2; i <= r; i++) {
printf("%s(%d,%d)", pr ? " " : "", i, c);
pr = true;
}
printf("\n");
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) g.push_back(II(i, j));
sort(g.begin(), g.end());
int ans = 0;
for (int i = 0; i < k; ++i) ans += g[i].ST + g[i].ND - 1;
printf("%d\n", ans);
int dem = 0;
for (int i = k - 1; i >= 0; --i) {
print(g[i].ST, g[i].ND);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
bool viz[100][100];
vector<pair<int, int>> d[150];
int n, m;
void print_location(int x, int y);
void parc(int x, int y, int l);
int main() {
int k, l = 1, penal = 0;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) viz[i][j] = 1;
parc(1, 1, 1);
while (d[l].size() <= k) {
penal += d[l].size() * l;
k -= d[l].size();
l++;
}
penal += l * k;
cout << penal << '\n';
for (int i = 0; i < k; i++) {
print_location(d[l][i].first, d[l][i].second);
cout << '\n';
}
for (int i = l - 1; i >= 1; --i) {
for (auto q : d[i]) {
print_location(q.first, q.second);
cout << '\n';
}
}
return 0;
}
void parc(int x, int y, int l) {
viz[x][y] = 0;
d[l].push_back({x, y});
if (viz[x + 1][y]) parc(x + 1, y, l + 1);
if (viz[x][y + 1]) parc(x, y + 1, l + 1);
}
void print_location(int x, int y) {
if (x > 1)
print_location(x - 1, y);
else if (y > 1)
print_location(x, y - 1);
cout << " (" << x << ',' << y << ')';
}
|
### Prompt
Please provide a Cpp coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool viz[100][100];
vector<pair<int, int>> d[150];
int n, m;
void print_location(int x, int y);
void parc(int x, int y, int l);
int main() {
int k, l = 1, penal = 0;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) viz[i][j] = 1;
parc(1, 1, 1);
while (d[l].size() <= k) {
penal += d[l].size() * l;
k -= d[l].size();
l++;
}
penal += l * k;
cout << penal << '\n';
for (int i = 0; i < k; i++) {
print_location(d[l][i].first, d[l][i].second);
cout << '\n';
}
for (int i = l - 1; i >= 1; --i) {
for (auto q : d[i]) {
print_location(q.first, q.second);
cout << '\n';
}
}
return 0;
}
void parc(int x, int y, int l) {
viz[x][y] = 0;
d[l].push_back({x, y});
if (viz[x + 1][y]) parc(x + 1, y, l + 1);
if (viz[x][y + 1]) parc(x, y + 1, l + 1);
}
void print_location(int x, int y) {
if (x > 1)
print_location(x - 1, y);
else if (y > 1)
print_location(x, y - 1);
cout << " (" << x << ',' << y << ')';
}
```
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long int myRand(long long int B) { return (unsigned long long)rng() % B; }
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, pair<int, int>>> v;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
v.push_back(make_pair(i + j, make_pair(i, j)));
}
}
sort(v.begin(), v.end());
int res = 0;
for (int i = 0; i < k; i++) {
res += v[i].first + 1;
}
printf("%d\n", res);
auto solve = [](int x, int y) -> void {
bool f = false;
x++;
y++;
int cx = 1, cy = 1;
printf("(%d,%d)", cx, cy);
while (cx + 1 <= x) {
cx++;
printf(" (%d,%d)", cx, cy);
}
while (cy + 1 <= y) {
cy++;
printf(" (%d,%d)", cx, cy);
}
printf("\n");
};
for (int i = k - 1; i >= 0; i--) {
solve(v[i].second.first, v[i].second.second);
}
}
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long int myRand(long long int B) { return (unsigned long long)rng() % B; }
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, pair<int, int>>> v;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
v.push_back(make_pair(i + j, make_pair(i, j)));
}
}
sort(v.begin(), v.end());
int res = 0;
for (int i = 0; i < k; i++) {
res += v[i].first + 1;
}
printf("%d\n", res);
auto solve = [](int x, int y) -> void {
bool f = false;
x++;
y++;
int cx = 1, cy = 1;
printf("(%d,%d)", cx, cy);
while (cx + 1 <= x) {
cx++;
printf(" (%d,%d)", cx, cy);
}
while (cy + 1 <= y) {
cy++;
printf(" (%d,%d)", cx, cy);
}
printf("\n");
};
for (int i = k - 1; i >= 0; i--) {
solve(v[i].second.first, v[i].second.second);
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
void output(int x, int y) {
int nx = 1, ny = 1;
int first = 0;
while (ny <= y) {
if (first++) cout << ' ';
cout << '(' << ny << ',' << nx << ')';
ny++;
}
ny--;
nx++;
while (nx <= x) {
if (first++) cout << ' ';
cout << '(' << ny << ',' << nx << ')';
nx++;
}
cout << endl;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
int x = 1, y = 1, lx = 1, ly = 1;
vector<pair<int, int> > v;
for (int i = 0; i < k; i++) {
v.push_back(make_pair(x, y));
ans += x + y - 1;
y++;
x--;
if (x == 0 || y > n) {
if (lx + 1 <= m)
lx++;
else
ly++;
x = lx;
y = ly;
}
}
cout << ans << endl;
for (int i = v.size() - 1; i >= 0; i--) output(v[i].first, v[i].second);
return 0;
}
|
### Prompt
Generate a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void output(int x, int y) {
int nx = 1, ny = 1;
int first = 0;
while (ny <= y) {
if (first++) cout << ' ';
cout << '(' << ny << ',' << nx << ')';
ny++;
}
ny--;
nx++;
while (nx <= x) {
if (first++) cout << ' ';
cout << '(' << ny << ',' << nx << ')';
nx++;
}
cout << endl;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
int x = 1, y = 1, lx = 1, ly = 1;
vector<pair<int, int> > v;
for (int i = 0; i < k; i++) {
v.push_back(make_pair(x, y));
ans += x + y - 1;
y++;
x--;
if (x == 0 || y > n) {
if (lx + 1 <= m)
lx++;
else
ly++;
x = lx;
y = ly;
}
}
cout << ans << endl;
for (int i = v.size() - 1; i >= 0; i--) output(v[i].first, v[i].second);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[60][60], num;
int dir[2][2] = {{1, 0}, {0, 1}};
bool vis[60][60];
struct node {
int first, second, len;
bool operator<(const node& next) const { return next.len < len; }
};
void bfs() {
memset(vis, 0, sizeof(vis));
memset(a, 0, sizeof(a));
static queue<pair<int, int> > que;
pair<int, int> p;
p.first = 1, p.second = 1, num = 1;
vis[1][1] = true, a[1][1] = 1;
if (num == k) return;
que.push(p);
while (!que.empty()) {
pair<int, int> now = que.front();
for (int i = 0; i < 2; i++) {
pair<int, int> next;
next.first = now.first + dir[i][0];
next.second = now.second + dir[i][1];
if (next.first >= 1 && next.first <= n && next.second >= 1 &&
next.second <= m && vis[next.first][next.second] == false) {
que.push(next);
vis[next.first][next.second] = true;
a[next.first][next.second] = a[now.first][now.second] + 1;
num++;
if (num == k) return;
}
}
que.pop();
}
}
int getAns() {
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
ans = ans + a[i][j];
}
}
return ans;
}
void show(node tmp) {
node now;
now.first = now.second = 1;
for (int i = now.first; i <= tmp.first; i++) {
cout << "(" << i << "," << 1 << ") ";
}
for (int i = now.second + 1; i <= tmp.second; i++) {
cout << "(" << tmp.first << "," << i << ") ";
}
cout << endl;
}
void print() {
static vector<node> vec;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j]) {
node tmp;
tmp.first = i, tmp.second = j, tmp.len = a[i][j];
vec.push_back(tmp);
}
}
}
sort(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
node tmp = vec[i];
show(tmp);
}
}
void work() {
memset(a, 0, sizeof(a));
bfs();
cout << getAns() << endl;
print();
}
int main() {
while (cin >> n >> m >> k) {
work();
}
return 0;
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[60][60], num;
int dir[2][2] = {{1, 0}, {0, 1}};
bool vis[60][60];
struct node {
int first, second, len;
bool operator<(const node& next) const { return next.len < len; }
};
void bfs() {
memset(vis, 0, sizeof(vis));
memset(a, 0, sizeof(a));
static queue<pair<int, int> > que;
pair<int, int> p;
p.first = 1, p.second = 1, num = 1;
vis[1][1] = true, a[1][1] = 1;
if (num == k) return;
que.push(p);
while (!que.empty()) {
pair<int, int> now = que.front();
for (int i = 0; i < 2; i++) {
pair<int, int> next;
next.first = now.first + dir[i][0];
next.second = now.second + dir[i][1];
if (next.first >= 1 && next.first <= n && next.second >= 1 &&
next.second <= m && vis[next.first][next.second] == false) {
que.push(next);
vis[next.first][next.second] = true;
a[next.first][next.second] = a[now.first][now.second] + 1;
num++;
if (num == k) return;
}
}
que.pop();
}
}
int getAns() {
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
ans = ans + a[i][j];
}
}
return ans;
}
void show(node tmp) {
node now;
now.first = now.second = 1;
for (int i = now.first; i <= tmp.first; i++) {
cout << "(" << i << "," << 1 << ") ";
}
for (int i = now.second + 1; i <= tmp.second; i++) {
cout << "(" << tmp.first << "," << i << ") ";
}
cout << endl;
}
void print() {
static vector<node> vec;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j]) {
node tmp;
tmp.first = i, tmp.second = j, tmp.len = a[i][j];
vec.push_back(tmp);
}
}
}
sort(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
node tmp = vec[i];
show(tmp);
}
}
void work() {
memset(a, 0, sizeof(a));
bfs();
cout << getAns() << endl;
print();
}
int main() {
while (cin >> n >> m >> k) {
work();
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, ans = 0;
int a[55][55];
cin >> n >> m >> k;
memset(a, 0, sizeof(a));
for (int i = 0; i < k; i++) {
int mini = 111, x, y;
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
if (mini > j + k - 1 && !a[j][k]) {
mini = j + k - 1;
x = j;
y = k;
}
}
}
a[x][y] = 1;
ans += mini;
}
printf("%d\n", ans);
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
if (a[i][j]) {
for (int c = 1, d = 1; c <= i; c++) {
if (c != i)
printf("(%d,%d) ", c, d);
else {
for (; d <= j; d++) {
if (d != j)
printf("(%d,%d) ", c, d);
else
printf("(%d,%d)\n", c, d);
}
}
}
}
}
}
return 0;
}
|
### Prompt
Please create a solution in CPP to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, ans = 0;
int a[55][55];
cin >> n >> m >> k;
memset(a, 0, sizeof(a));
for (int i = 0; i < k; i++) {
int mini = 111, x, y;
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
if (mini > j + k - 1 && !a[j][k]) {
mini = j + k - 1;
x = j;
y = k;
}
}
}
a[x][y] = 1;
ans += mini;
}
printf("%d\n", ans);
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
if (a[i][j]) {
for (int c = 1, d = 1; c <= i; c++) {
if (c != i)
printf("(%d,%d) ", c, d);
else {
for (; d <= j; d++) {
if (d != j)
printf("(%d,%d) ", c, d);
else
printf("(%d,%d)\n", c, d);
}
}
}
}
}
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
class p {
public:
int len, r, c;
p(int len, int r, int c) : len(len), r(r), c(c) {}
};
bool cmp(const p &i, const p &j) { return i.len < j.len; }
int d[51][51], n, m, k;
pair<int, int> par[51][51];
int dr[4] = {-1, 0, 1, 0}, dc[4] = {0, 1, 0, -1};
bool pos(int r, int c) { return 1 <= r && r <= n && 1 <= c && c <= m; }
vector<p> bfs(int sr, int sc) {
queue<pair<int, int> > q;
memset(d, -1, sizeof(d));
q.push(pair<int, int>(sr, sc));
d[sr][sc] = 0;
while (!q.empty()) {
int cr = q.front().first, cc = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int nr = cr + dr[i], nc = cc + dc[i];
if (pos(nr, nc) && d[nr][nc] < 0) {
d[nr][nc] = d[cr][cc] + 1;
par[nr][nc] = pair<int, int>(cr, cc);
q.push(pair<int, int>(nr, nc));
}
}
}
vector<p> v;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) v.push_back(p(d[i][j], i, j));
}
sort(v.begin(), v.end(), cmp);
v.erase(v.begin() + k, v.end());
return v;
}
vector<vector<pair<int, int> > > rr;
void trace(p &x) {
vector<pair<int, int> > tr;
for (int cr = x.r, cc = x.c; par[cr][cc].first > 0;) {
tr.push_back(pair<int, int>(cr, cc));
int nr = par[cr][cc].first, nc = par[cr][cc].second;
cr = nr;
cc = nc;
}
tr.push_back(pair<int, int>(1, 1));
reverse(tr.begin(), tr.end());
rr.push_back(tr);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) par[i][j].first = par[i][j].second = -1;
}
vector<p> res = bfs(1, 1);
int sum = 0;
for (int i = res.size() - 1; i >= 0; i--) {
trace(res[i]);
sum += rr.back().size();
}
printf("%d\n", sum);
for (int i = 0; i < rr.size(); i++) {
for (int j = 0; j < rr[i].size(); j++)
printf("(%d,%d) ", rr[i][j].first, rr[i][j].second);
puts("");
}
return 0;
}
|
### Prompt
In CPP, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
class p {
public:
int len, r, c;
p(int len, int r, int c) : len(len), r(r), c(c) {}
};
bool cmp(const p &i, const p &j) { return i.len < j.len; }
int d[51][51], n, m, k;
pair<int, int> par[51][51];
int dr[4] = {-1, 0, 1, 0}, dc[4] = {0, 1, 0, -1};
bool pos(int r, int c) { return 1 <= r && r <= n && 1 <= c && c <= m; }
vector<p> bfs(int sr, int sc) {
queue<pair<int, int> > q;
memset(d, -1, sizeof(d));
q.push(pair<int, int>(sr, sc));
d[sr][sc] = 0;
while (!q.empty()) {
int cr = q.front().first, cc = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int nr = cr + dr[i], nc = cc + dc[i];
if (pos(nr, nc) && d[nr][nc] < 0) {
d[nr][nc] = d[cr][cc] + 1;
par[nr][nc] = pair<int, int>(cr, cc);
q.push(pair<int, int>(nr, nc));
}
}
}
vector<p> v;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) v.push_back(p(d[i][j], i, j));
}
sort(v.begin(), v.end(), cmp);
v.erase(v.begin() + k, v.end());
return v;
}
vector<vector<pair<int, int> > > rr;
void trace(p &x) {
vector<pair<int, int> > tr;
for (int cr = x.r, cc = x.c; par[cr][cc].first > 0;) {
tr.push_back(pair<int, int>(cr, cc));
int nr = par[cr][cc].first, nc = par[cr][cc].second;
cr = nr;
cc = nc;
}
tr.push_back(pair<int, int>(1, 1));
reverse(tr.begin(), tr.end());
rr.push_back(tr);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) par[i][j].first = par[i][j].second = -1;
}
vector<p> res = bfs(1, 1);
int sum = 0;
for (int i = res.size() - 1; i >= 0; i--) {
trace(res[i]);
sum += rr.back().size();
}
printf("%d\n", sum);
for (int i = 0; i < rr.size(); i++) {
for (int j = 0; j < rr[i].size(); j++)
printf("(%d,%d) ", rr[i][j].first, rr[i][j].second);
puts("");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
void path(array<int, 2> &p) {
array<int, 2> curr = {0, 0};
while (true) {
cout << "(" << curr[0] + 1 << "," << curr[1] + 1 << ") ";
if (curr == p) break;
if (curr[1] < p[1])
curr[1]++;
else
curr[0]++;
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<array<int, 2>> nodes(k);
vector<vector<array<int, 2>>> diag(n + m);
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)m; j++) diag[i + j].push_back({i, j});
int ans = 0;
for (int s = 0; s < (int)n + m; s++) {
for (auto &i : diag[s]) {
if (!k) break;
ans += s + 1;
k--;
nodes[k] = i;
}
}
cout << ans << '\n';
for (auto &i : nodes) path(i);
}
|
### Prompt
Develop a solution in Cpp to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void path(array<int, 2> &p) {
array<int, 2> curr = {0, 0};
while (true) {
cout << "(" << curr[0] + 1 << "," << curr[1] + 1 << ") ";
if (curr == p) break;
if (curr[1] < p[1])
curr[1]++;
else
curr[0]++;
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<array<int, 2>> nodes(k);
vector<vector<array<int, 2>>> diag(n + m);
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)m; j++) diag[i + j].push_back({i, j});
int ans = 0;
for (int s = 0; s < (int)n + m; s++) {
for (auto &i : diag[s]) {
if (!k) break;
ans += s + 1;
k--;
nodes[k] = i;
}
}
cout << ans << '\n';
for (auto &i : nodes) path(i);
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, cnt;
bool bio[55][55], ad[55][55];
vector<pair<int, int> > curr, sol;
void fill() {
vector<pair<int, int> > novi;
for (int i = 0; i < curr.size(); i++) {
if (curr[i].first > n || curr[i].second > m) continue;
if (!bio[curr[i].first][curr[i].second]) {
sol.push_back(curr[i]);
bio[curr[i].first][curr[i].second] = 1;
cnt += curr[i].first - 1 + curr[i].second;
}
if (sol.size() == k) return;
if (!ad[curr[i].first + 1][curr[i].second]) {
ad[curr[i].first + 1][curr[i].second] = 1;
novi.push_back(make_pair(curr[i].first + 1, curr[i].second));
}
if (!ad[curr[i].first][curr[i].second + 1]) {
ad[curr[i].first][curr[i].second + 1] = 1;
novi.push_back(make_pair(curr[i].first, curr[i].second + 1));
}
}
curr = novi;
fill();
}
void path(pair<int, int> x) {
int cx = 1, cy = 1;
printf("(%d,%d) ", cx, cy);
for (int i = 0; i < x.first - 1; i++) {
cx++;
printf("(%d,%d) ", cx, cy);
}
for (int i = 0; i < x.second - 1; i++) {
cy++;
printf("(%d,%d) ", cx, cy);
}
printf("\n");
}
int main(void) {
ios::sync_with_stdio(false);
scanf("%d%d%d", &n, &m, &k);
curr.push_back(make_pair(1, 1));
fill();
printf("%d\n", cnt);
for (int i = k - 1; i >= 0; i--) path(sol[i]);
return 0;
}
|
### Prompt
Please create a solution in Cpp to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, cnt;
bool bio[55][55], ad[55][55];
vector<pair<int, int> > curr, sol;
void fill() {
vector<pair<int, int> > novi;
for (int i = 0; i < curr.size(); i++) {
if (curr[i].first > n || curr[i].second > m) continue;
if (!bio[curr[i].first][curr[i].second]) {
sol.push_back(curr[i]);
bio[curr[i].first][curr[i].second] = 1;
cnt += curr[i].first - 1 + curr[i].second;
}
if (sol.size() == k) return;
if (!ad[curr[i].first + 1][curr[i].second]) {
ad[curr[i].first + 1][curr[i].second] = 1;
novi.push_back(make_pair(curr[i].first + 1, curr[i].second));
}
if (!ad[curr[i].first][curr[i].second + 1]) {
ad[curr[i].first][curr[i].second + 1] = 1;
novi.push_back(make_pair(curr[i].first, curr[i].second + 1));
}
}
curr = novi;
fill();
}
void path(pair<int, int> x) {
int cx = 1, cy = 1;
printf("(%d,%d) ", cx, cy);
for (int i = 0; i < x.first - 1; i++) {
cx++;
printf("(%d,%d) ", cx, cy);
}
for (int i = 0; i < x.second - 1; i++) {
cy++;
printf("(%d,%d) ", cx, cy);
}
printf("\n");
}
int main(void) {
ios::sync_with_stdio(false);
scanf("%d%d%d", &n, &m, &k);
curr.push_back(make_pair(1, 1));
fill();
printf("%d\n", cnt);
for (int i = k - 1; i >= 0; i--) path(sol[i]);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int n, m, k;
int f[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};
bool vis[maxn][maxn];
struct Node {
int x, y;
friend bool operator<(const Node n1, const Node n2) {
if (n1.x != n2.x)
return n1.x < n2.x;
else
return n1.y < n2.y;
}
};
priority_queue<Node> Q;
queue<Node> q;
int BFS(int num) {
int ans = 0;
memset(vis, false, sizeof vis);
Node u;
u.x = 1, u.y = 1;
q.push(u);
vis[1][1] = true;
num--;
Q.push(u);
ans = 1;
while (!q.empty() && num) {
Node now = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int nx = now.x + f[i][0];
int ny = now.y + f[i][1];
if (nx < 1 || ny < 1 || nx > n || ny > m || vis[nx][ny]) continue;
vis[nx][ny] = true;
num--;
Node next;
next.x = nx, next.y = ny;
q.push(next);
Q.push(next);
ans += ((nx - 1) + (ny - 1) + 1);
if (num == 0) return ans;
}
}
return ans;
}
int main() {
cin >> n >> m >> k;
int ans = BFS(k);
cout << ans << endl;
while (!Q.empty()) {
Node now = Q.top();
Q.pop();
int x = now.x, y = now.y;
for (int i = 1; i <= x; i++) {
printf("(%d,1)", i);
if (y == 1 && i == x)
cout << endl;
else
cout << " ";
}
for (int i = 2; i <= y; i++) {
printf("(%d,%d)", x, i);
if (i == y)
cout << endl;
else
cout << " ";
}
}
return 0;
}
|
### Prompt
Please create a solution in CPP to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int n, m, k;
int f[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};
bool vis[maxn][maxn];
struct Node {
int x, y;
friend bool operator<(const Node n1, const Node n2) {
if (n1.x != n2.x)
return n1.x < n2.x;
else
return n1.y < n2.y;
}
};
priority_queue<Node> Q;
queue<Node> q;
int BFS(int num) {
int ans = 0;
memset(vis, false, sizeof vis);
Node u;
u.x = 1, u.y = 1;
q.push(u);
vis[1][1] = true;
num--;
Q.push(u);
ans = 1;
while (!q.empty() && num) {
Node now = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int nx = now.x + f[i][0];
int ny = now.y + f[i][1];
if (nx < 1 || ny < 1 || nx > n || ny > m || vis[nx][ny]) continue;
vis[nx][ny] = true;
num--;
Node next;
next.x = nx, next.y = ny;
q.push(next);
Q.push(next);
ans += ((nx - 1) + (ny - 1) + 1);
if (num == 0) return ans;
}
}
return ans;
}
int main() {
cin >> n >> m >> k;
int ans = BFS(k);
cout << ans << endl;
while (!Q.empty()) {
Node now = Q.top();
Q.pop();
int x = now.x, y = now.y;
for (int i = 1; i <= x; i++) {
printf("(%d,1)", i);
if (y == 1 && i == x)
cout << endl;
else
cout << " ";
}
for (int i = 2; i <= y; i++) {
printf("(%d,%d)", x, i);
if (i == y)
cout << endl;
else
cout << " ";
}
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
bool bo[55][55];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
struct node {
int x, y, d;
} q[5000];
int main() {
int i, j, k, n, m, tail, ans;
scanf("%d%d%d", &n, &m, &k);
memset(bo, 0, sizeof(bo));
tail = 1;
q[0].x = 1;
q[0].y = 1;
q[0].d = 1;
ans = 0;
bo[1][1] = true;
for (i = 0; i < tail; i++) {
if (tail >= k) break;
for (j = 0; j < 4; j++) {
int xx, yy;
xx = q[i].x + dx[j];
yy = q[i].y + dy[j];
if (xx < 1 || xx > n || yy < 1 || yy > m || bo[xx][yy]) continue;
bo[xx][yy] = true;
q[tail].x = xx;
q[tail].y = yy;
q[tail++].d = q[i].d + 1;
}
}
ans = 0;
for (i = k - 1; i >= 0; i--) ans += q[i].d;
printf("%d\n", ans);
for (i = k - 1; i >= 0; i--) {
int x, y, f = 0;
x = 1;
y = 1;
while (x <= q[i].x && y <= q[i].y) {
if (f) printf(" ");
f++;
printf("(%d,%d)", x, y);
if (x == q[i].x)
y++;
else
x++;
}
printf("\n");
}
}
|
### Prompt
Please provide a CPP coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool bo[55][55];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
struct node {
int x, y, d;
} q[5000];
int main() {
int i, j, k, n, m, tail, ans;
scanf("%d%d%d", &n, &m, &k);
memset(bo, 0, sizeof(bo));
tail = 1;
q[0].x = 1;
q[0].y = 1;
q[0].d = 1;
ans = 0;
bo[1][1] = true;
for (i = 0; i < tail; i++) {
if (tail >= k) break;
for (j = 0; j < 4; j++) {
int xx, yy;
xx = q[i].x + dx[j];
yy = q[i].y + dy[j];
if (xx < 1 || xx > n || yy < 1 || yy > m || bo[xx][yy]) continue;
bo[xx][yy] = true;
q[tail].x = xx;
q[tail].y = yy;
q[tail++].d = q[i].d + 1;
}
}
ans = 0;
for (i = k - 1; i >= 0; i--) ans += q[i].d;
printf("%d\n", ans);
for (i = k - 1; i >= 0; i--) {
int x, y, f = 0;
x = 1;
y = 1;
while (x <= q[i].x && y <= q[i].y) {
if (f) printf(" ");
f++;
printf("(%d,%d)", x, y);
if (x == q[i].x)
y++;
else
x++;
}
printf("\n");
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
int sum = 0;
for (int i = 2; i <= n + m; i++) {
for (int j = 1; j <= n; j++) {
if (j < i && sum < k && i - j <= m) {
int g = i - j;
sum++;
ans += j + g - 1;
v.push_back(make_pair(j, g));
}
}
}
sort(v.begin(), v.end());
cout << ans << endl;
for (int i = (int)v.size() - 1; i >= 0; i--) {
int a = v[i].first;
int b = v[i].second;
for (int i = 1; i <= b; i++) {
printf("(1, %d) ", i);
}
for (int i = 2; i <= a; i++) {
printf("(%d, %d) ", i, b);
}
cout << endl;
}
return 0;
}
|
### Prompt
Your task is to create a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
int sum = 0;
for (int i = 2; i <= n + m; i++) {
for (int j = 1; j <= n; j++) {
if (j < i && sum < k && i - j <= m) {
int g = i - j;
sum++;
ans += j + g - 1;
v.push_back(make_pair(j, g));
}
}
}
sort(v.begin(), v.end());
cout << ans << endl;
for (int i = (int)v.size() - 1; i >= 0; i--) {
int a = v[i].first;
int b = v[i].second;
for (int i = 1; i <= b; i++) {
printf("(1, %d) ", i);
}
for (int i = 2; i <= a; i++) {
printf("(%d, %d) ", i, b);
}
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
stack<pair<int, int> > targetPoints;
queue<pair<int, int> > q;
int penalty;
int tx[] = {0, 1};
int ty[] = {1, 0};
bool visited[51][51];
bool validTargetPoint(int x, int y, int maxX, int maxY) {
if (x > maxX || y > maxY || x < 1 || y < 1) return 0;
if (visited[x][y]) return 0;
visited[x][y] = true;
return 1;
}
void findTargetPoints(int n, int m, int k) {
penalty = 2;
targetPoints.push(pair<int, int>(1, 1));
q.push(pair<int, int>(1, 1));
visited[1][1] = true;
k--;
if (k) {
while (!q.empty()) {
struct pair<int, int> xyPair = q.front();
q.pop();
for (int p = 0; p < 2; p++) {
if (validTargetPoint(xyPair.first + tx[p], xyPair.second + ty[p], n,
m)) {
targetPoints.push(
pair<int, int>(xyPair.first + tx[p], xyPair.second + ty[p]));
q.push(pair<int, int>(xyPair.first + tx[p], xyPair.second + ty[p]));
k--;
penalty += xyPair.first + tx[p] + xyPair.second + ty[p];
if (k == 0) break;
}
}
if (k == 0) break;
}
}
penalty -= targetPoints.size();
}
void printPathFor(pair<int, int> coordinate) {
int targetX = coordinate.first;
int targetY = coordinate.second;
int i = 1, j = 1;
for (i = 1; i < targetX; i++) {
printf("(%d,%d) ", i, 1);
}
if (targetY != 1)
printf("(%d,%d) ", i, 1);
else
printf("(%d,%d)\n", i, 1);
for (j = 2; j < targetY; j++) {
printf("(%d,%d) ", i, j);
}
if (targetY != 1) printf("(%d,%d)\n", i, j);
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
findTargetPoints(n, m, k);
printf("%d\n", penalty);
while (!targetPoints.empty()) {
pair<int, int> targetCoordinate = targetPoints.top();
printPathFor(targetCoordinate);
targetPoints.pop();
}
return 0;
}
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
stack<pair<int, int> > targetPoints;
queue<pair<int, int> > q;
int penalty;
int tx[] = {0, 1};
int ty[] = {1, 0};
bool visited[51][51];
bool validTargetPoint(int x, int y, int maxX, int maxY) {
if (x > maxX || y > maxY || x < 1 || y < 1) return 0;
if (visited[x][y]) return 0;
visited[x][y] = true;
return 1;
}
void findTargetPoints(int n, int m, int k) {
penalty = 2;
targetPoints.push(pair<int, int>(1, 1));
q.push(pair<int, int>(1, 1));
visited[1][1] = true;
k--;
if (k) {
while (!q.empty()) {
struct pair<int, int> xyPair = q.front();
q.pop();
for (int p = 0; p < 2; p++) {
if (validTargetPoint(xyPair.first + tx[p], xyPair.second + ty[p], n,
m)) {
targetPoints.push(
pair<int, int>(xyPair.first + tx[p], xyPair.second + ty[p]));
q.push(pair<int, int>(xyPair.first + tx[p], xyPair.second + ty[p]));
k--;
penalty += xyPair.first + tx[p] + xyPair.second + ty[p];
if (k == 0) break;
}
}
if (k == 0) break;
}
}
penalty -= targetPoints.size();
}
void printPathFor(pair<int, int> coordinate) {
int targetX = coordinate.first;
int targetY = coordinate.second;
int i = 1, j = 1;
for (i = 1; i < targetX; i++) {
printf("(%d,%d) ", i, 1);
}
if (targetY != 1)
printf("(%d,%d) ", i, 1);
else
printf("(%d,%d)\n", i, 1);
for (j = 2; j < targetY; j++) {
printf("(%d,%d) ", i, j);
}
if (targetY != 1) printf("(%d,%d)\n", i, j);
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
findTargetPoints(n, m, k);
printf("%d\n", penalty);
while (!targetPoints.empty()) {
pair<int, int> targetCoordinate = targetPoints.top();
printPathFor(targetCoordinate);
targetPoints.pop();
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
queue<pair<int, int>> q;
void addPath(list<pair<int, int>>& l) {
for (auto p : l) {
q.push(p);
}
q.push({0, 0});
}
pair<int, int> dum = {0, 0};
void print() {
while (!q.empty()) {
if (q.front() == dum) {
q.pop();
if (!q.empty())
printf("\n");
else
break;
} else {
printf("(%d,%d) ", q.front().first, q.front().second);
q.pop();
}
}
}
int main() {
std::ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
std::vector<vector<bool>> grid(n + 1, vector<bool>(m + 1, 0));
int curR = 1, curC = 1, r = 1, c = 1;
while (k) {
grid[r][c] = 1;
k--;
r++;
c--;
if (c == 0 || r == n + 1) {
r = curR;
curC++;
c = curC;
if (curC == m + 1) {
curC = m;
curR++;
r = curR;
c = curC;
}
}
}
long long int ans = 0;
for (int c = m; c > 0; c--) {
for (int r = n; r > 0; r--) {
if (grid[r][c]) {
list<pair<int, int>> q;
int row = 0, col = 0;
ans += (r * c);
ans += (r * (r - 1)) / 2;
while (col < c) {
col++;
q.insert(q.end(), {row + 1, col});
}
row++;
while (row < r) {
row++;
q.insert(q.end(), {row, col});
}
addPath(q);
r--;
auto it = q.end();
it--;
q.erase(it);
while (r) {
addPath(q);
auto it = q.end();
it--;
q.erase(it);
r--;
}
}
}
}
printf("%lld\n", ans);
print();
}
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
queue<pair<int, int>> q;
void addPath(list<pair<int, int>>& l) {
for (auto p : l) {
q.push(p);
}
q.push({0, 0});
}
pair<int, int> dum = {0, 0};
void print() {
while (!q.empty()) {
if (q.front() == dum) {
q.pop();
if (!q.empty())
printf("\n");
else
break;
} else {
printf("(%d,%d) ", q.front().first, q.front().second);
q.pop();
}
}
}
int main() {
std::ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
std::vector<vector<bool>> grid(n + 1, vector<bool>(m + 1, 0));
int curR = 1, curC = 1, r = 1, c = 1;
while (k) {
grid[r][c] = 1;
k--;
r++;
c--;
if (c == 0 || r == n + 1) {
r = curR;
curC++;
c = curC;
if (curC == m + 1) {
curC = m;
curR++;
r = curR;
c = curC;
}
}
}
long long int ans = 0;
for (int c = m; c > 0; c--) {
for (int r = n; r > 0; r--) {
if (grid[r][c]) {
list<pair<int, int>> q;
int row = 0, col = 0;
ans += (r * c);
ans += (r * (r - 1)) / 2;
while (col < c) {
col++;
q.insert(q.end(), {row + 1, col});
}
row++;
while (row < r) {
row++;
q.insert(q.end(), {row, col});
}
addPath(q);
r--;
auto it = q.end();
it--;
q.erase(it);
while (r) {
addPath(q);
auto it = q.end();
it--;
q.erase(it);
r--;
}
}
}
}
printf("%lld\n", ans);
print();
}
```
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const double EPS = 1e-9;
const int N = 1e5 + 9;
int n, m, k;
vector<vector<pair<int, int>>> ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
int cnt = 0;
for (int i = 1; i <= n; i++) {
int x = i, y = 1;
while (k && x >= 1 && y <= m) {
vector<pair<int, int>> t;
for (int j = 1; j <= y; j++) t.push_back({1, j});
for (int j = 2; j <= x; j++) t.push_back({j, y});
cnt += x + y - 1;
ans.push_back(t);
x--;
y++;
k--;
}
}
for (int i = 2; i <= m; i++) {
int x = n, y = i;
while (k && x >= 1 && y <= m) {
vector<pair<int, int>> t;
for (int j = 1; j <= y; j++) t.push_back({1, j});
for (int j = 2; j <= x; j++) t.push_back({j, y});
cnt += x + y - 1;
ans.push_back(t);
x--;
y++;
k--;
}
}
cout << cnt << endl;
for (int i = ans.size() - 1; i > -1; i--) {
for (auto p : ans[i]) cout << "(" << p.first << "," << p.second << ") ";
cout << endl;
}
return 0;
}
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const double EPS = 1e-9;
const int N = 1e5 + 9;
int n, m, k;
vector<vector<pair<int, int>>> ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
int cnt = 0;
for (int i = 1; i <= n; i++) {
int x = i, y = 1;
while (k && x >= 1 && y <= m) {
vector<pair<int, int>> t;
for (int j = 1; j <= y; j++) t.push_back({1, j});
for (int j = 2; j <= x; j++) t.push_back({j, y});
cnt += x + y - 1;
ans.push_back(t);
x--;
y++;
k--;
}
}
for (int i = 2; i <= m; i++) {
int x = n, y = i;
while (k && x >= 1 && y <= m) {
vector<pair<int, int>> t;
for (int j = 1; j <= y; j++) t.push_back({1, j});
for (int j = 2; j <= x; j++) t.push_back({j, y});
cnt += x + y - 1;
ans.push_back(t);
x--;
y++;
k--;
}
}
cout << cnt << endl;
for (int i = ans.size() - 1; i > -1; i--) {
for (auto p : ans[i]) cout << "(" << p.first << "," << p.second << ") ";
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
stack<pair<int, int>> st;
int ans = 0;
int x = 1, y = 1;
for (int i = 0; i < k; i++) {
ans += (x + y - 1);
st.push({x, y});
x--;
y++;
if (x < 1 || y > m) {
x++;
while (x < n && y > 1) {
x++;
y--;
}
}
}
printf("%d\n", ans);
while (!st.empty()) {
auto f = st.top();
st.pop();
for (int x = 1; x <= f.first; x++) {
printf("(%d,1) ", x);
}
for (int y = 2; y <= f.second; y++) {
printf("(%d,%d) ", f.first, y);
}
printf("\n");
}
return 0;
}
|
### Prompt
Generate a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
stack<pair<int, int>> st;
int ans = 0;
int x = 1, y = 1;
for (int i = 0; i < k; i++) {
ans += (x + y - 1);
st.push({x, y});
x--;
y++;
if (x < 1 || y > m) {
x++;
while (x < n && y > 1) {
x++;
y--;
}
}
}
printf("%d\n", ans);
while (!st.empty()) {
auto f = st.top();
st.pop();
for (int x = 1; x <= f.first; x++) {
printf("(%d,1) ", x);
}
for (int y = 2; y <= f.second; y++) {
printf("(%d,%d) ", f.first, y);
}
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
struct state {
int x, y;
} p[N];
int n, m, k, c;
bool cmp(const state& a, const state& b) { return a.x + a.y < b.x + b.y; }
void init() {
c = 0;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p[c].x = i;
p[c].y = j;
c++;
}
}
sort(p, p + c, cmp);
}
void handle(int x, int y) {
for (int i = 1; i <= x; i++) printf("(%d,1) ", i);
for (int i = 2; i <= y; i++) printf("(%d,%d) ", x, i);
printf("\n");
}
void solve() {
int ans = 0;
for (int i = 0; i < k; i++) ans += p[i].x + p[i].y - 1;
printf("%d\n", ans);
for (int i = k - 1; i >= 0; i--) {
handle(p[i].x, p[i].y);
}
}
int main() {
init();
solve();
return 0;
}
|
### Prompt
Construct a cpp code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
struct state {
int x, y;
} p[N];
int n, m, k, c;
bool cmp(const state& a, const state& b) { return a.x + a.y < b.x + b.y; }
void init() {
c = 0;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p[c].x = i;
p[c].y = j;
c++;
}
}
sort(p, p + c, cmp);
}
void handle(int x, int y) {
for (int i = 1; i <= x; i++) printf("(%d,1) ", i);
for (int i = 2; i <= y; i++) printf("(%d,%d) ", x, i);
printf("\n");
}
void solve() {
int ans = 0;
for (int i = 0; i < k; i++) ans += p[i].x + p[i].y - 1;
printf("%d\n", ans);
for (int i = k - 1; i >= 0; i--) {
handle(p[i].x, p[i].y);
}
}
int main() {
init();
solve();
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct pos {
int i, j, d;
pos left() { return {i, j - 1, d + 1}; }
pos right() { return {i, j + 1, d + 1}; }
pos up() { return {i - 1, j, d + 1}; }
pos down() { return {i + 1, j, d + 1}; }
};
int n, m, k;
pos d[100][100];
queue<pos> q;
bool check(pos p) {
return p.i > 0 && p.j > 0 && p.i <= n && p.j <= m && !d[p.i][p.j].d;
}
void visit(pos prev, pos next) {
if (!check(next)) return;
d[next.i][next.j] = prev;
d[next.i][next.j].d++;
q.push(next);
}
int depthcnt[200];
stack<pos> stk;
void place1(int i, int j) {
pos p = {i, j, 0};
stk.push(p);
while (p.i != 1 || p.j != 1) {
stk.push(d[p.i][p.j]);
p = d[p.i][p.j];
}
while (!stk.empty()) {
pos t = stk.top();
printf("(%d,%d) ", t.i, t.j);
stk.pop();
}
printf("\n");
}
void place(int k, int depth) {
int starti, startj;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (d[i][j].d == depth) {
starti = i;
startj = j;
goto lbl;
}
}
}
lbl:
for (int i = 0; i < k; i++) {
place1(starti, startj);
starti++;
startj--;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
q.push({1, 1, 1});
d[1][1] = {0, 0, 1};
while (!q.empty()) {
pos t = q.front();
q.pop();
pos tn;
visit(t, t.left());
visit(t, t.right());
visit(t, t.up());
visit(t, t.down());
}
int nk = k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
depthcnt[d[i][j].d]++;
}
}
int maxdepth = 0;
long long res = 0;
while (nk >= depthcnt[maxdepth]) {
nk -= depthcnt[maxdepth];
res += maxdepth * depthcnt[maxdepth];
maxdepth++;
}
res += maxdepth * nk;
printf("%I64d\n", res);
int to_place = nk;
for (; maxdepth > 0; maxdepth--) {
place(to_place, maxdepth);
to_place = depthcnt[maxdepth - 1];
}
return 0;
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct pos {
int i, j, d;
pos left() { return {i, j - 1, d + 1}; }
pos right() { return {i, j + 1, d + 1}; }
pos up() { return {i - 1, j, d + 1}; }
pos down() { return {i + 1, j, d + 1}; }
};
int n, m, k;
pos d[100][100];
queue<pos> q;
bool check(pos p) {
return p.i > 0 && p.j > 0 && p.i <= n && p.j <= m && !d[p.i][p.j].d;
}
void visit(pos prev, pos next) {
if (!check(next)) return;
d[next.i][next.j] = prev;
d[next.i][next.j].d++;
q.push(next);
}
int depthcnt[200];
stack<pos> stk;
void place1(int i, int j) {
pos p = {i, j, 0};
stk.push(p);
while (p.i != 1 || p.j != 1) {
stk.push(d[p.i][p.j]);
p = d[p.i][p.j];
}
while (!stk.empty()) {
pos t = stk.top();
printf("(%d,%d) ", t.i, t.j);
stk.pop();
}
printf("\n");
}
void place(int k, int depth) {
int starti, startj;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (d[i][j].d == depth) {
starti = i;
startj = j;
goto lbl;
}
}
}
lbl:
for (int i = 0; i < k; i++) {
place1(starti, startj);
starti++;
startj--;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
q.push({1, 1, 1});
d[1][1] = {0, 0, 1};
while (!q.empty()) {
pos t = q.front();
q.pop();
pos tn;
visit(t, t.left());
visit(t, t.right());
visit(t, t.up());
visit(t, t.down());
}
int nk = k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
depthcnt[d[i][j].d]++;
}
}
int maxdepth = 0;
long long res = 0;
while (nk >= depthcnt[maxdepth]) {
nk -= depthcnt[maxdepth];
res += maxdepth * depthcnt[maxdepth];
maxdepth++;
}
res += maxdepth * nk;
printf("%I64d\n", res);
int to_place = nk;
for (; maxdepth > 0; maxdepth--) {
place(to_place, maxdepth);
to_place = depthcnt[maxdepth - 1];
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T MAX(T a, T b) {
if (a > b) return a;
return b;
}
template <class T>
inline T MIN(T a, T b) {
if (a < b) return a;
return b;
}
template <class T>
inline T ABS(T x) {
if (x < 0) return -x;
return x;
}
inline void OPEN(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const static int inf = 1000000000;
int n, m, k;
int res = 0;
vector<set<pair<int, int> > > path;
void bfs(int r, int c) {
queue<pair<pair<int, int>, int> > q;
q.push(make_pair(make_pair(r, c), 1));
int butuh = k;
bool visited[55][55] = {};
set<pair<int, int> > temp;
while (butuh) {
pair<int, int> now = q.front().first;
int move = q.front().second;
q.pop();
if (visited[now.first][now.second]) continue;
visited[now.first][now.second] = true;
res += move;
temp.clear();
for (int(i) = (1); (i) <= (now.first); ++(i)) temp.insert(make_pair(i, 1));
for (int(i) = (1); (i) <= (now.second); ++(i)) {
temp.insert(make_pair(now.first, i));
}
path.push_back(temp);
butuh--;
static int dx[] = {0, 1, 0, -1};
static int dy[] = {-1, 0, 1, 0};
for (int(i) = (0); (i) < (4); ++(i)) {
int xx = now.second + dx[i];
int yy = now.first + dy[i];
if (xx < 1 || xx > m || yy < 1 || yy > n) continue;
if (visited[yy][xx]) continue;
q.push(make_pair(make_pair(yy, xx), move + 1));
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
bfs(1, 1);
printf("%d\n", res);
reverse((path).begin(), (path).end());
for (int(i) = (0); (i) < (path.size()); ++(i)) {
bool spasi = false;
for (__typeof((path[i]).begin()) it = (path[i]).begin();
it != (path[i]).end(); it++) {
if (spasi)
printf(" ");
else
spasi = true;
printf("(%d,%d)", it->first, it->second);
}
printf("\n");
}
return 0;
}
|
### Prompt
Please provide a CPP coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T MAX(T a, T b) {
if (a > b) return a;
return b;
}
template <class T>
inline T MIN(T a, T b) {
if (a < b) return a;
return b;
}
template <class T>
inline T ABS(T x) {
if (x < 0) return -x;
return x;
}
inline void OPEN(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const static int inf = 1000000000;
int n, m, k;
int res = 0;
vector<set<pair<int, int> > > path;
void bfs(int r, int c) {
queue<pair<pair<int, int>, int> > q;
q.push(make_pair(make_pair(r, c), 1));
int butuh = k;
bool visited[55][55] = {};
set<pair<int, int> > temp;
while (butuh) {
pair<int, int> now = q.front().first;
int move = q.front().second;
q.pop();
if (visited[now.first][now.second]) continue;
visited[now.first][now.second] = true;
res += move;
temp.clear();
for (int(i) = (1); (i) <= (now.first); ++(i)) temp.insert(make_pair(i, 1));
for (int(i) = (1); (i) <= (now.second); ++(i)) {
temp.insert(make_pair(now.first, i));
}
path.push_back(temp);
butuh--;
static int dx[] = {0, 1, 0, -1};
static int dy[] = {-1, 0, 1, 0};
for (int(i) = (0); (i) < (4); ++(i)) {
int xx = now.second + dx[i];
int yy = now.first + dy[i];
if (xx < 1 || xx > m || yy < 1 || yy > n) continue;
if (visited[yy][xx]) continue;
q.push(make_pair(make_pair(yy, xx), move + 1));
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
bfs(1, 1);
printf("%d\n", res);
reverse((path).begin(), (path).end());
for (int(i) = (0); (i) < (path.size()); ++(i)) {
bool spasi = false;
for (__typeof((path[i]).begin()) it = (path[i]).begin();
it != (path[i]).end(); it++) {
if (spasi)
printf(" ");
else
spasi = true;
printf("(%d,%d)", it->first, it->second);
}
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, w, e, r, t, y, c, v, a[2500], s[2500];
bool d[50][50];
cin >> q >> w >> c;
for (e = 0; e < q; e++)
for (v = 0; v < w; v++) d[e][v] = 1;
d[0][0] = 0;
a[0] = s[0] = 0;
e = 0;
r = t = 1;
while (e < r) {
for (; e < r; e++) {
if (a[e] < q - 1)
if (d[a[e] + 1][s[e]]) {
d[a[e] + 1][s[e]] = 0;
a[t] = a[e] + 1;
s[t] = s[e];
t++;
}
if (s[e] < w - 1)
if (d[a[e]][s[e] + 1]) {
d[a[e]][s[e] + 1] = 0;
a[t] = a[e];
s[t] = s[e] + 1;
t++;
}
}
r = t;
}
for (e = v = 0; e < c; e++) {
v += a[e] + s[e] + 1;
}
cout << v << "\n";
for (e = c - 1; e >= 0; e--) {
printf("(1,1)");
for (r = 1; r <= a[e]; r++) printf(" (%d,%d)", r + 1, 1);
for (r = 1; r <= s[e]; r++) printf(" (%d,%d)", a[e] + 1, r + 1);
printf("\n");
}
return 0;
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, w, e, r, t, y, c, v, a[2500], s[2500];
bool d[50][50];
cin >> q >> w >> c;
for (e = 0; e < q; e++)
for (v = 0; v < w; v++) d[e][v] = 1;
d[0][0] = 0;
a[0] = s[0] = 0;
e = 0;
r = t = 1;
while (e < r) {
for (; e < r; e++) {
if (a[e] < q - 1)
if (d[a[e] + 1][s[e]]) {
d[a[e] + 1][s[e]] = 0;
a[t] = a[e] + 1;
s[t] = s[e];
t++;
}
if (s[e] < w - 1)
if (d[a[e]][s[e] + 1]) {
d[a[e]][s[e] + 1] = 0;
a[t] = a[e];
s[t] = s[e] + 1;
t++;
}
}
r = t;
}
for (e = v = 0; e < c; e++) {
v += a[e] + s[e] + 1;
}
cout << v << "\n";
for (e = c - 1; e >= 0; e--) {
printf("(1,1)");
for (r = 1; r <= a[e]; r++) printf(" (%d,%d)", r + 1, 1);
for (r = 1; r <= s[e]; r++) printf(" (%d,%d)", a[e] + 1, r + 1);
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
void print_path(int i, int j) {
vector<pair<int, int> > ans;
while (i) {
ans.push_back({i, j});
i--;
}
while (j) {
ans.push_back({i, j});
j--;
}
ans.push_back({0, 0});
reverse(ans.begin(), ans.end());
for (auto pr : ans) {
cout << '(' << pr.first + 1 << ',' << pr.second + 1 << ')' << ' ';
}
cout << endl;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int arr[n][m];
vector<pair<int, pair<int, int> > > v;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
v.push_back({i + j, {i, j}});
}
}
sort(v.begin(), v.end());
int sum = 0;
for (int i = k - 1; i >= 0; i--) {
sum += (v[i].first + 1);
}
cout << sum << endl;
for (int i = k - 1; i >= 0; i--) {
print_path(v[i].second.first, v[i].second.second);
}
return 0;
}
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void print_path(int i, int j) {
vector<pair<int, int> > ans;
while (i) {
ans.push_back({i, j});
i--;
}
while (j) {
ans.push_back({i, j});
j--;
}
ans.push_back({0, 0});
reverse(ans.begin(), ans.end());
for (auto pr : ans) {
cout << '(' << pr.first + 1 << ',' << pr.second + 1 << ')' << ' ';
}
cout << endl;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int arr[n][m];
vector<pair<int, pair<int, int> > > v;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
v.push_back({i + j, {i, j}});
}
}
sort(v.begin(), v.end());
int sum = 0;
for (int i = k - 1; i >= 0; i--) {
sum += (v[i].first + 1);
}
cout << sum << endl;
for (int i = k - 1; i >= 0; i--) {
print_path(v[i].second.first, v[i].second.second);
}
return 0;
}
```
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const double infd = 2e+9;
const int infi = 1ll << 30;
const long long infl = 1ll << 60;
const int mod = 1e+9 + 7;
template <class T>
inline T sqr(T x) {
return x * x;
}
vector<vector<pair<int, int> > > answer;
int path_length = 0, top = -1;
inline void put_end() {
answer.push_back(vector<pair<int, int> >());
top++;
}
inline void put(int x, int y) {
path_length++;
answer[top].push_back(make_pair(x, y));
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int cn = 0;
bool was = n * m == k;
for (int len = n + m - 2; len >= 0; len--) {
for (int x = len; x >= 0; x--) {
int y = len - x;
if (!(0 <= y && y < m && 0 <= x && x < n)) continue;
cn++;
if (was) {
put_end();
for (int i = 0; i <= x; i++) put(i, 0);
for (int i = 1; i <= y; i++) put(x, i);
}
if (cn == n * m - k) was = true;
}
}
cout << path_length << endl;
for (int i = 0; i < (int)answer.size(); i++) {
for (int j = 0; j < (int)answer[i].size(); j++) {
cout << '(' << answer[i][j].first + 1 << ',' << answer[i][j].second + 1
<< ") ";
}
cout << endl;
}
return 0;
}
|
### Prompt
Construct a CPP code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const double infd = 2e+9;
const int infi = 1ll << 30;
const long long infl = 1ll << 60;
const int mod = 1e+9 + 7;
template <class T>
inline T sqr(T x) {
return x * x;
}
vector<vector<pair<int, int> > > answer;
int path_length = 0, top = -1;
inline void put_end() {
answer.push_back(vector<pair<int, int> >());
top++;
}
inline void put(int x, int y) {
path_length++;
answer[top].push_back(make_pair(x, y));
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int cn = 0;
bool was = n * m == k;
for (int len = n + m - 2; len >= 0; len--) {
for (int x = len; x >= 0; x--) {
int y = len - x;
if (!(0 <= y && y < m && 0 <= x && x < n)) continue;
cn++;
if (was) {
put_end();
for (int i = 0; i <= x; i++) put(i, 0);
for (int i = 1; i <= y; i++) put(x, i);
}
if (cn == n * m - k) was = true;
}
}
cout << path_length << endl;
for (int i = 0; i < (int)answer.size(); i++) {
for (int j = 0; j < (int)answer[i].size(); j++) {
cout << '(' << answer[i][j].first + 1 << ',' << answer[i][j].second + 1
<< ") ";
}
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct II {
int ST, ND;
II(int a = 0, int b = 0) : ST(a), ND(b) {}
bool operator<(const II& op) const {
if (ST + ND != op.ST + op.ND) return ST + ND < op.ST + op.ND;
return ST > op.ST;
}
};
vector<II> g;
void print(int r, int c) {
bool pr = false;
for (int j = 1; j <= c; ++j) printf("(%d,%d) ", 1, j);
for (int j = 2; j <= r; ++j) printf("(%d,%d) ", j, c);
printf("\n");
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) g.push_back(II(i, j));
sort(g.begin(), g.end());
int ans = 0;
for (int i = 0; i < k; ++i) ans += g[i].ST + g[i].ND - 1;
printf("%d\n", ans);
int dem = 0;
for (int i = k - 1; i >= 0; --i) {
print(g[i].ST, g[i].ND);
}
return 0;
}
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct II {
int ST, ND;
II(int a = 0, int b = 0) : ST(a), ND(b) {}
bool operator<(const II& op) const {
if (ST + ND != op.ST + op.ND) return ST + ND < op.ST + op.ND;
return ST > op.ST;
}
};
vector<II> g;
void print(int r, int c) {
bool pr = false;
for (int j = 1; j <= c; ++j) printf("(%d,%d) ", 1, j);
for (int j = 2; j <= r; ++j) printf("(%d,%d) ", j, c);
printf("\n");
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) g.push_back(II(i, j));
sort(g.begin(), g.end());
int ans = 0;
for (int i = 0; i < k; ++i) ans += g[i].ST + g[i].ND - 1;
printf("%d\n", ans);
int dem = 0;
for (int i = k - 1; i >= 0; --i) {
print(g[i].ST, g[i].ND);
}
return 0;
}
```
|
#include <bits/stdc++.h>
int flag;
void printx(int pos) {
int x, i, j, k;
for (x = pos; x >= 1; x--) {
for (i = x; i >= 1; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (k = 2; k <= x - i + 1; k++) {
if (flag == 0)
printf("(%d,%d)\t", k, i);
else
printf("(%d,%d)\t", i, k);
}
printf("\n");
}
}
}
void printy(int pos, int n) {
int len, j, k, s;
for (len = pos; len >= n + 1; len--) {
for (j = len; j >= len - n + 1; j--) {
for (k = 1; k <= j; k++) {
if (flag == 0)
printf("(1,%d)\t", k);
else
printf("(%d,1)\t", k);
}
for (s = 2; s <= len - j + 1; s++) {
if (flag == 0)
printf("(%d,%d)\t", s, j);
else
printf("(%d,%d)\t", j, s);
}
printf("\n");
}
}
}
int main() {
int k, n, m, no = 0, pos, new_pos, i, j, s, temp;
scanf("%d%d%d", &n, &m, &k);
if (m < n) {
temp = n;
n = m;
m = temp;
flag = 1;
}
if (k <= n * (n + 1) / 2) {
pos = ((int)sqrt(8 * k + 1) - 1) / 2;
no += pos * (pos + 1) * (2 * pos + 1) / 6;
new_pos = k - pos * (pos + 1) / 2;
no += new_pos * (pos + 1);
printf("%d\n", no);
for (i = pos + 1; i >= pos + 2 - new_pos; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (s = 2; s <= pos + 2 - i; s++) {
if (flag == 0)
printf("(%d,%d)", s, i);
else
printf("(%d,%d)", i, s);
}
printf("\n");
}
printx(pos);
} else if (k - n * (n + 1) / 2 <= n * (m - n)) {
int s1 = (k - n * (n + 1) / 2) / n;
int s2 = (k - n * (n + 1) / 2) % n;
no = n * (n + 1) * (2 * n + 1) / 6 + n * (n * s1 + s1 * (s1 + 1) / 2) +
(n + s1 + 1) * s2;
printf("%d\n", no);
if (s2 != 0) {
for (i = n + s1 + 1; i >= n + s1 + 2 - s2; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (s = 2; s <= n + s1 + 2 - i; s++) {
if (flag == 0)
printf("(%d,%d)\t", s, i);
else
printf("(%d,%d)\t", i, s);
}
printf("\n");
}
}
printy(n + s1, n);
printx(n);
} else {
int rest = 0;
k = k - n * (n + 1) / 2 - n * (m - n);
k = n * (n - 1) / 2 - k;
pos = ((int)sqrt(8 * k + 1) - 1) / 2;
if (k - pos * (pos + 1) / 2 != 0) {
rest = pos + 1 - k + pos * (pos + 1) / 2;
pos = n - 1 - (pos + 1);
} else
pos = n - 1 - pos;
no = n * (n + 1) * (2 * n + 1) / 6 +
n * (n * (m - n) + (m - n) * (m - n + 1) / 2) -
pos * (pos + 1) * (2 * pos + 1) / 6 + (-m + n) * pos * (pos + 1) / 2 +
(m + pos + 1) * rest + m * n * pos;
printf("%d\n", no);
if (rest != 0) {
for (i = m; i >= m - rest + 1; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (k = 2; k <= m + pos + 2 - i; k++) {
if (flag == 0)
printf("(%d,%d)\t", k, i);
else
printf("(%d,%d)\t", i, k);
}
printf("\n");
}
}
int len;
for (len = m + pos; len >= m + 1; len--) {
for (i = m; i >= len - n + 1; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (k = 2; k <= len - i + 1; k++) {
if (flag == 0)
printf("(%d,%d)\t", k, i);
else
printf("(%d,%d)\t", i, k);
}
printf("\n");
}
}
printy(m, n);
printx(n);
}
return 0;
}
|
### Prompt
Generate a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
int flag;
void printx(int pos) {
int x, i, j, k;
for (x = pos; x >= 1; x--) {
for (i = x; i >= 1; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (k = 2; k <= x - i + 1; k++) {
if (flag == 0)
printf("(%d,%d)\t", k, i);
else
printf("(%d,%d)\t", i, k);
}
printf("\n");
}
}
}
void printy(int pos, int n) {
int len, j, k, s;
for (len = pos; len >= n + 1; len--) {
for (j = len; j >= len - n + 1; j--) {
for (k = 1; k <= j; k++) {
if (flag == 0)
printf("(1,%d)\t", k);
else
printf("(%d,1)\t", k);
}
for (s = 2; s <= len - j + 1; s++) {
if (flag == 0)
printf("(%d,%d)\t", s, j);
else
printf("(%d,%d)\t", j, s);
}
printf("\n");
}
}
}
int main() {
int k, n, m, no = 0, pos, new_pos, i, j, s, temp;
scanf("%d%d%d", &n, &m, &k);
if (m < n) {
temp = n;
n = m;
m = temp;
flag = 1;
}
if (k <= n * (n + 1) / 2) {
pos = ((int)sqrt(8 * k + 1) - 1) / 2;
no += pos * (pos + 1) * (2 * pos + 1) / 6;
new_pos = k - pos * (pos + 1) / 2;
no += new_pos * (pos + 1);
printf("%d\n", no);
for (i = pos + 1; i >= pos + 2 - new_pos; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (s = 2; s <= pos + 2 - i; s++) {
if (flag == 0)
printf("(%d,%d)", s, i);
else
printf("(%d,%d)", i, s);
}
printf("\n");
}
printx(pos);
} else if (k - n * (n + 1) / 2 <= n * (m - n)) {
int s1 = (k - n * (n + 1) / 2) / n;
int s2 = (k - n * (n + 1) / 2) % n;
no = n * (n + 1) * (2 * n + 1) / 6 + n * (n * s1 + s1 * (s1 + 1) / 2) +
(n + s1 + 1) * s2;
printf("%d\n", no);
if (s2 != 0) {
for (i = n + s1 + 1; i >= n + s1 + 2 - s2; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (s = 2; s <= n + s1 + 2 - i; s++) {
if (flag == 0)
printf("(%d,%d)\t", s, i);
else
printf("(%d,%d)\t", i, s);
}
printf("\n");
}
}
printy(n + s1, n);
printx(n);
} else {
int rest = 0;
k = k - n * (n + 1) / 2 - n * (m - n);
k = n * (n - 1) / 2 - k;
pos = ((int)sqrt(8 * k + 1) - 1) / 2;
if (k - pos * (pos + 1) / 2 != 0) {
rest = pos + 1 - k + pos * (pos + 1) / 2;
pos = n - 1 - (pos + 1);
} else
pos = n - 1 - pos;
no = n * (n + 1) * (2 * n + 1) / 6 +
n * (n * (m - n) + (m - n) * (m - n + 1) / 2) -
pos * (pos + 1) * (2 * pos + 1) / 6 + (-m + n) * pos * (pos + 1) / 2 +
(m + pos + 1) * rest + m * n * pos;
printf("%d\n", no);
if (rest != 0) {
for (i = m; i >= m - rest + 1; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (k = 2; k <= m + pos + 2 - i; k++) {
if (flag == 0)
printf("(%d,%d)\t", k, i);
else
printf("(%d,%d)\t", i, k);
}
printf("\n");
}
}
int len;
for (len = m + pos; len >= m + 1; len--) {
for (i = m; i >= len - n + 1; i--) {
for (j = 1; j <= i; j++) {
if (flag == 0)
printf("(1,%d)\t", j);
else
printf("(%d,1)\t", j);
}
for (k = 2; k <= len - i + 1; k++) {
if (flag == 0)
printf("(%d,%d)\t", k, i);
else
printf("(%d,%d)\t", i, k);
}
printf("\n");
}
}
printy(m, n);
printx(n);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int mark[maxn][maxn];
int n, m, k;
long long ans = 0;
void make() {
int mini = 200, andis1, andis2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i + j + 1 < mini && mark[i][j] == 0)
andis1 = i, andis2 = j, mini = i + j + 1;
}
}
mark[andis1][andis2] = 1;
ans += mini;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) make();
cout << ans << endl;
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (mark[i][j] == 1) {
for (int k = 0; k <= i - 1; k++)
cout << "(" << k + 1 << ","
<< "1"
<< ")";
for (int k = 0; k <= j; k++)
cout << "(" << i + 1 << "," << k + 1 << ")";
cout << endl;
}
}
}
return 0;
}
|
### Prompt
Develop a solution in Cpp to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int mark[maxn][maxn];
int n, m, k;
long long ans = 0;
void make() {
int mini = 200, andis1, andis2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i + j + 1 < mini && mark[i][j] == 0)
andis1 = i, andis2 = j, mini = i + j + 1;
}
}
mark[andis1][andis2] = 1;
ans += mini;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) make();
cout << ans << endl;
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (mark[i][j] == 1) {
for (int k = 0; k <= i - 1; k++)
cout << "(" << k + 1 << ","
<< "1"
<< ")";
for (int k = 0; k <= j; k++)
cout << "(" << i + 1 << "," << k + 1 << ")";
cout << endl;
}
}
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int n, m, k;
int build(int u, int v) {
for (int i = 1; i <= u; i++) printf("(%d,1) ", i);
for (int i = 2; i <= v; i++) printf("(%d,%d) ", u, i);
return 0;
}
pair<int, int> p[5000];
int main() {
scanf("%d%d%d", &n, &m, &k);
p[1].first = 1;
p[1].second = 1;
for (int i = 2; i <= k; i++) {
if (p[i - 1].first == n || p[i - 1].second == 1) {
int s = p[i - 1].first + p[i - 1].second + 1;
for (int j = 1; j <= n; j++) {
if ((s - j) <= m) {
p[i].first = j;
p[i].second = s - j;
break;
}
}
} else {
p[i].first = p[i - 1].first + 1;
p[i].second = p[i - 1].second - 1;
}
}
int num = 0;
for (int i = 1; i <= k; i++) {
num += p[i].first + p[i].second - 1;
}
cout << num << endl;
for (int i = k; i >= 1; i--) {
build(p[i].first, p[i].second);
puts("");
}
return 0;
}
|
### Prompt
Please create a solution in cpp to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int n, m, k;
int build(int u, int v) {
for (int i = 1; i <= u; i++) printf("(%d,1) ", i);
for (int i = 2; i <= v; i++) printf("(%d,%d) ", u, i);
return 0;
}
pair<int, int> p[5000];
int main() {
scanf("%d%d%d", &n, &m, &k);
p[1].first = 1;
p[1].second = 1;
for (int i = 2; i <= k; i++) {
if (p[i - 1].first == n || p[i - 1].second == 1) {
int s = p[i - 1].first + p[i - 1].second + 1;
for (int j = 1; j <= n; j++) {
if ((s - j) <= m) {
p[i].first = j;
p[i].second = s - j;
break;
}
}
} else {
p[i].first = p[i - 1].first + 1;
p[i].second = p[i - 1].second - 1;
}
}
int num = 0;
for (int i = 1; i <= k; i++) {
num += p[i].first + p[i].second - 1;
}
cout << num << endl;
for (int i = k; i >= 1; i--) {
build(p[i].first, p[i].second);
puts("");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int>> cn(long long int n, long long int m) {
return vector<vector<long long int>>(n, vector<long long int>(m));
}
bool compare(char &s1, char &s2) { return s1 > s2; }
bool sortmahstyle(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first < b.first) return true;
if (a.first == b.first && a.second != b.second) return true;
return false;
}
long long int const mod = 998244353;
long long int const inf = 1e18;
long long int const maxn = 1e5 + 1;
void solve() {
long long int n, m, k;
cin >> n >> m >> k;
long long int s;
long long int a[n][m];
memset(a, 0, sizeof a);
for (long long int i = 0; i < n; i++) {
long long int cur = i;
for (long long int j = 0; k && cur >= 0 && j < m; j++, cur--) {
a[cur][j] = 1, k--;
}
}
for (long long int j = 1; j < m; j++) {
long long int cur = j;
for (long long int i = n - 1; k && cur < m && i >= 0; i--, cur++)
a[i][cur] = 1, k--;
}
long long int it = 0;
vector<pair<long long int, long long int>> ans[maxn];
for (long long int i = n - 1; i >= 0; i--) {
for (long long int j = m - 1; j >= 0; j--) {
if (a[i][j] == 1) {
long long int x = i, y = j;
long long int lastx = i, lasty = j;
while (y >= 0) {
ans[it].push_back({x, y});
lastx = x, lasty = y;
y--;
}
while (x >= 0) ans[it].push_back({x, 0}), x--;
it++;
}
}
}
vector<pair<long long int, long long int>> fans[maxn];
long long int itt = 0;
s = 0;
for (long long int i = 0; i < it; i++) {
map<pair<long long int, long long int>, long long int> used;
reverse(ans[i].begin(), ans[i].end());
for (pair<long long int, long long int> e : ans[i]) {
if (used[{e.first, e.second}] == 0) {
fans[itt].push_back({e.first, e.second}), s++;
used[{e.first, e.second}] = 1;
}
}
itt++;
}
cout << s << "\n";
for (long long int i = 0; i < itt; i++) {
for (pair<long long int, long long int> e : fans[i]) {
cout << "(" << e.first + 1 << "," << e.second + 1 << ") ";
}
cout << "\n";
;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
t = 1;
for (long long int testcases = 0; testcases < t; testcases++) {
solve();
}
return 0;
}
|
### Prompt
Generate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int>> cn(long long int n, long long int m) {
return vector<vector<long long int>>(n, vector<long long int>(m));
}
bool compare(char &s1, char &s2) { return s1 > s2; }
bool sortmahstyle(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first < b.first) return true;
if (a.first == b.first && a.second != b.second) return true;
return false;
}
long long int const mod = 998244353;
long long int const inf = 1e18;
long long int const maxn = 1e5 + 1;
void solve() {
long long int n, m, k;
cin >> n >> m >> k;
long long int s;
long long int a[n][m];
memset(a, 0, sizeof a);
for (long long int i = 0; i < n; i++) {
long long int cur = i;
for (long long int j = 0; k && cur >= 0 && j < m; j++, cur--) {
a[cur][j] = 1, k--;
}
}
for (long long int j = 1; j < m; j++) {
long long int cur = j;
for (long long int i = n - 1; k && cur < m && i >= 0; i--, cur++)
a[i][cur] = 1, k--;
}
long long int it = 0;
vector<pair<long long int, long long int>> ans[maxn];
for (long long int i = n - 1; i >= 0; i--) {
for (long long int j = m - 1; j >= 0; j--) {
if (a[i][j] == 1) {
long long int x = i, y = j;
long long int lastx = i, lasty = j;
while (y >= 0) {
ans[it].push_back({x, y});
lastx = x, lasty = y;
y--;
}
while (x >= 0) ans[it].push_back({x, 0}), x--;
it++;
}
}
}
vector<pair<long long int, long long int>> fans[maxn];
long long int itt = 0;
s = 0;
for (long long int i = 0; i < it; i++) {
map<pair<long long int, long long int>, long long int> used;
reverse(ans[i].begin(), ans[i].end());
for (pair<long long int, long long int> e : ans[i]) {
if (used[{e.first, e.second}] == 0) {
fans[itt].push_back({e.first, e.second}), s++;
used[{e.first, e.second}] = 1;
}
}
itt++;
}
cout << s << "\n";
for (long long int i = 0; i < itt; i++) {
for (pair<long long int, long long int> e : fans[i]) {
cout << "(" << e.first + 1 << "," << e.second + 1 << ") ";
}
cout << "\n";
;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
t = 1;
for (long long int testcases = 0; testcases < t; testcases++) {
solve();
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, -1, 0, 0};
int dy[] = {0, 0, 0, 1, -1};
pair<int, int> sir[100 * 100];
pair<int, int> T[100][100];
queue<pair<int, int> > q;
int n, m, sol, k, t, D[100][100];
void go(int x, int y) {
if (x == 1 && y == 1) {
cout << "(1,1) ";
return;
}
go(T[x][y].first, T[x][y].second);
cout << "(" << x << "," << y << ") ";
}
void bfs(int x, int y) {
q.push(make_pair(x, y));
D[x][y] = 1;
while (!q.empty()) {
pair<int, int> a = q.front();
q.pop();
sir[++t] = a;
if (t == k) return;
for (int i = 1; i <= 4; ++i) {
x = a.first + dx[i];
y = a.second + dy[i];
if (x < 1 || x > n || y < 1 || y > m) continue;
if (D[x][y]) continue;
D[x][y] = D[a.first][a.second] + 1;
T[x][y] = make_pair(a.first, a.second);
q.push(make_pair(x, y));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
bfs(1, 1);
for (int i = 1; i <= k; ++i) sol += D[sir[i].first][sir[i].second];
cout << sol << "\n";
for (int i = k; i >= 1; --i) {
go(sir[i].first, sir[i].second);
cout << "\n";
}
return 0;
}
|
### Prompt
Create a solution in cpp for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, -1, 0, 0};
int dy[] = {0, 0, 0, 1, -1};
pair<int, int> sir[100 * 100];
pair<int, int> T[100][100];
queue<pair<int, int> > q;
int n, m, sol, k, t, D[100][100];
void go(int x, int y) {
if (x == 1 && y == 1) {
cout << "(1,1) ";
return;
}
go(T[x][y].first, T[x][y].second);
cout << "(" << x << "," << y << ") ";
}
void bfs(int x, int y) {
q.push(make_pair(x, y));
D[x][y] = 1;
while (!q.empty()) {
pair<int, int> a = q.front();
q.pop();
sir[++t] = a;
if (t == k) return;
for (int i = 1; i <= 4; ++i) {
x = a.first + dx[i];
y = a.second + dy[i];
if (x < 1 || x > n || y < 1 || y > m) continue;
if (D[x][y]) continue;
D[x][y] = D[a.first][a.second] + 1;
T[x][y] = make_pair(a.first, a.second);
q.push(make_pair(x, y));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
bfs(1, 1);
for (int i = 1; i <= k; ++i) sol += D[sir[i].first][sir[i].second];
cout << sol << "\n";
for (int i = k; i >= 1; --i) {
go(sir[i].first, sir[i].second);
cout << "\n";
}
return 0;
}
```
|
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int yuzu = 1e5;
pair<int, int> a[yuzu | 10];
void print(int tx, int ty) {
int i;
for (i = 1; i <= ty; ++i) printf("(1,%d) ", i);
for (i = 2; i <= tx; ++i) printf("(%d,%d) ", i, ty);
}
int n, m, k;
int main() {
n = read(), m = read(), k = read();
int t, ans = 0, i = 1, j = 1, x = 1;
for (t = 1; t <= k; t++) {
a[t] = pair<int, int>(i, j);
++i, --j;
if (j >= m) --t;
if (i > x || i > n) i = 1, j = ++x;
}
int llx = 0;
for (i = 1; i <= k; ++i) llx += a[i].first + a[i].second;
cout << llx - k << endl;
for (i = k; i; --i, puts("")) print(a[i].first, a[i].second);
}
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int yuzu = 1e5;
pair<int, int> a[yuzu | 10];
void print(int tx, int ty) {
int i;
for (i = 1; i <= ty; ++i) printf("(1,%d) ", i);
for (i = 2; i <= tx; ++i) printf("(%d,%d) ", i, ty);
}
int n, m, k;
int main() {
n = read(), m = read(), k = read();
int t, ans = 0, i = 1, j = 1, x = 1;
for (t = 1; t <= k; t++) {
a[t] = pair<int, int>(i, j);
++i, --j;
if (j >= m) --t;
if (i > x || i > n) i = 1, j = ++x;
}
int llx = 0;
for (i = 1; i <= k; ++i) llx += a[i].first + a[i].second;
cout << llx - k << endl;
for (i = k; i; --i, puts("")) print(a[i].first, a[i].second);
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<pair<int, int> > vec;
bool comp(pair<int, int> a, pair<int, int> b) {
if ((a.first + a.second) != (b.first + b.second)) {
return (a.first + a.second) < (b.first + b.second);
} else
return a.first * a.second < b.first * b.second;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
vec.push_back(make_pair(i, j));
}
}
sort(vec.begin(), vec.end(), comp);
int total = 0;
vector<pair<int, int> > q, ans;
for (int i = 0; i < k; i++) {
q.push_back(vec[i]);
}
for (int i = 0; i < k; i++) {
total += (q[i].first - 1) + (q[i].second - 1);
}
printf("%d\n", total + k);
for (int r = q.size() - 1; r >= 0; r--) {
int x = q[r].first;
int y = q[r].second;
ans.clear();
for (int i = 1; i <= x; i++) {
ans.push_back(make_pair(i, 1));
}
for (int i = 2; i <= y; i++) {
ans.push_back(make_pair(x, i));
}
for (int i = 0; i < ans.size(); i++) {
if (i) printf(" ");
printf("(%d,%d)", ans[i].first, ans[i].second);
}
printf("\n");
}
return 0;
}
|
### Prompt
Your task is to create a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<pair<int, int> > vec;
bool comp(pair<int, int> a, pair<int, int> b) {
if ((a.first + a.second) != (b.first + b.second)) {
return (a.first + a.second) < (b.first + b.second);
} else
return a.first * a.second < b.first * b.second;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
vec.push_back(make_pair(i, j));
}
}
sort(vec.begin(), vec.end(), comp);
int total = 0;
vector<pair<int, int> > q, ans;
for (int i = 0; i < k; i++) {
q.push_back(vec[i]);
}
for (int i = 0; i < k; i++) {
total += (q[i].first - 1) + (q[i].second - 1);
}
printf("%d\n", total + k);
for (int r = q.size() - 1; r >= 0; r--) {
int x = q[r].first;
int y = q[r].second;
ans.clear();
for (int i = 1; i <= x; i++) {
ans.push_back(make_pair(i, 1));
}
for (int i = 2; i <= y; i++) {
ans.push_back(make_pair(x, i));
}
for (int i = 0; i < ans.size(); i++) {
if (i) printf(" ");
printf("(%d,%d)", ans[i].first, ans[i].second);
}
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, tot;
vector<pair<int, int> > ans;
void prt(int x, int y) { printf(" (%d,%d)", x + 1, y + 1); }
int main() {
scanf("%d%d%d", &n, &m, &k);
tot = 0;
for (int i = 1; i < n + m && k > 0; i++) {
int piece = i - max(0, i - n) - max(0, i - m);
int det = min(piece, k);
k -= det;
tot += det * i;
ans.push_back(make_pair(i, det));
}
printf("%d\n", tot);
for (int i = ans.size() - 1; i >= 0; i--) {
int det = ans[i].first - 1, mul = ans[i].second;
int dx = min(n - 1, det), dy = det - dx;
for (int j = 0; j < mul; j++) {
printf("(1,1)");
int x = 0, y = 0;
for (int l = 0; l < dx; l++) {
x++;
prt(x, y);
}
for (int l = 0; l < dy; l++) {
y++;
prt(x, y);
}
dx--;
dy++;
printf("\n");
}
}
return 0;
}
|
### Prompt
Please provide a CPP coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, tot;
vector<pair<int, int> > ans;
void prt(int x, int y) { printf(" (%d,%d)", x + 1, y + 1); }
int main() {
scanf("%d%d%d", &n, &m, &k);
tot = 0;
for (int i = 1; i < n + m && k > 0; i++) {
int piece = i - max(0, i - n) - max(0, i - m);
int det = min(piece, k);
k -= det;
tot += det * i;
ans.push_back(make_pair(i, det));
}
printf("%d\n", tot);
for (int i = ans.size() - 1; i >= 0; i--) {
int det = ans[i].first - 1, mul = ans[i].second;
int dx = min(n - 1, det), dy = det - dx;
for (int j = 0; j < mul; j++) {
printf("(1,1)");
int x = 0, y = 0;
for (int l = 0; l < dx; l++) {
x++;
prt(x, y);
}
for (int l = 0; l < dy; l++) {
y++;
prt(x, y);
}
dx--;
dy++;
printf("\n");
}
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int mod = 1e9 + 7;
int n, m, k, ans, num;
struct node {
int i, j;
} a[N];
bool cmp(node a, node b) { return a.i + a.j < b.i + b.j; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++) {
a[++num].i = i;
a[num].j = j;
}
sort(a + 1, a + num + 1, cmp);
for (int i = (1); i < (k + 1); i++) {
ans += a[i].i + a[i].j - 1;
}
printf("%d\n", ans);
for (int i = k; i >= 1; i--) {
for (int j = (1); j < (a[i].i + 1); j++) printf("(%d,%d) ", j, 1);
for (int j = (2); j < (a[i].j + 1); j++) printf("(%d,%d) ", a[i].i, j);
puts("");
}
return 0;
}
|
### Prompt
Please provide a CPP coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int mod = 1e9 + 7;
int n, m, k, ans, num;
struct node {
int i, j;
} a[N];
bool cmp(node a, node b) { return a.i + a.j < b.i + b.j; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++) {
a[++num].i = i;
a[num].j = j;
}
sort(a + 1, a + num + 1, cmp);
for (int i = (1); i < (k + 1); i++) {
ans += a[i].i + a[i].j - 1;
}
printf("%d\n", ans);
for (int i = k; i >= 1; i--) {
for (int j = (1); j < (a[i].i + 1); j++) printf("(%d,%d) ", j, 1);
for (int j = (2); j < (a[i].j + 1); j++) printf("(%d,%d) ", a[i].i, j);
puts("");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct nodo {
int x, y;
int id;
int pred;
int niv;
nodo() {}
nodo(int xx, int yy) {
x = xx;
y = yy;
id = x * 50 + y;
pred = 0;
}
};
nodo nod[10000];
stack<nodo> pila;
int pred[10000];
int X[] = {0, 0, 1, -1};
int Y[] = {1, -1, 0, 0};
int total = 0;
bool flag[10000];
void bfs() {
queue<nodo> cola;
nodo raiz = nodo(1, 1);
raiz.pred = raiz.id;
raiz.niv = 1;
cola.push(raiz);
flag[raiz.id] = 1;
while (!cola.empty()) {
nodo act = cola.front();
nod[act.id] = act;
pila.push(act);
total += act.niv;
if (pila.size() == k) {
return;
}
cola.pop();
for (int i = 0; i < 4; i++) {
nodo hijo = nodo(X[i] + act.x, Y[i] + act.y);
if (hijo.x >= 1 && hijo.x <= n && hijo.y >= 1 && hijo.y <= m &&
!flag[hijo.id]) {
flag[hijo.id] = 1;
hijo.pred = act.id;
hijo.niv = act.niv + 1;
cola.push(hijo);
}
}
}
}
void imp(int x, int y) { cout << "(" << x << "," << y << ")"; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
bfs();
cout << total << '\n';
stack<nodo> pila2;
while (!pila.empty()) {
nodo act = pila.top();
pila.pop();
int cont = 0;
while (act.id != act.pred) {
cont++;
pila2.push(act);
act = nod[act.pred];
}
imp(1, 1);
while (!pila2.empty()) {
cout << " ";
imp(pila2.top().x, pila2.top().y);
pila2.pop();
}
cout << '\n';
}
return 0;
}
|
### Prompt
In cpp, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct nodo {
int x, y;
int id;
int pred;
int niv;
nodo() {}
nodo(int xx, int yy) {
x = xx;
y = yy;
id = x * 50 + y;
pred = 0;
}
};
nodo nod[10000];
stack<nodo> pila;
int pred[10000];
int X[] = {0, 0, 1, -1};
int Y[] = {1, -1, 0, 0};
int total = 0;
bool flag[10000];
void bfs() {
queue<nodo> cola;
nodo raiz = nodo(1, 1);
raiz.pred = raiz.id;
raiz.niv = 1;
cola.push(raiz);
flag[raiz.id] = 1;
while (!cola.empty()) {
nodo act = cola.front();
nod[act.id] = act;
pila.push(act);
total += act.niv;
if (pila.size() == k) {
return;
}
cola.pop();
for (int i = 0; i < 4; i++) {
nodo hijo = nodo(X[i] + act.x, Y[i] + act.y);
if (hijo.x >= 1 && hijo.x <= n && hijo.y >= 1 && hijo.y <= m &&
!flag[hijo.id]) {
flag[hijo.id] = 1;
hijo.pred = act.id;
hijo.niv = act.niv + 1;
cola.push(hijo);
}
}
}
}
void imp(int x, int y) { cout << "(" << x << "," << y << ")"; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
bfs();
cout << total << '\n';
stack<nodo> pila2;
while (!pila.empty()) {
nodo act = pila.top();
pila.pop();
int cont = 0;
while (act.id != act.pred) {
cont++;
pila2.push(act);
act = nod[act.pred];
}
imp(1, 1);
while (!pila2.empty()) {
cout << " ";
imp(pila2.top().x, pila2.top().y);
pila2.pop();
}
cout << '\n';
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int x, y;
} a[3010];
int n, m, k;
int sz;
int ans;
bool cmp(data a, data b) { return a.x + a.y < b.x + b.y; }
void doing() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
a[++sz].x = i;
a[sz].y = j;
}
sort(a + 1, a + 1 + sz, cmp);
for (int i = 1; i <= k; i++) ans += a[i].x + a[i].y - 1;
cout << ans << endl;
for (int i = k; i >= 1; i--) {
for (int j = 1; j <= a[i].x; j++) printf("(%d,1) ", j);
for (int j = 2; j <= a[i].y; j++) printf("(%d,%d) ", a[i].x, j);
puts("");
}
}
int main() {
doing();
return 0;
}
|
### Prompt
Construct a cpp code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct data {
int x, y;
} a[3010];
int n, m, k;
int sz;
int ans;
bool cmp(data a, data b) { return a.x + a.y < b.x + b.y; }
void doing() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
a[++sz].x = i;
a[sz].y = j;
}
sort(a + 1, a + 1 + sz, cmp);
for (int i = 1; i <= k; i++) ans += a[i].x + a[i].y - 1;
cout << ans << endl;
for (int i = k; i >= 1; i--) {
for (int j = 1; j <= a[i].x; j++) printf("(%d,1) ", j);
for (int j = 2; j <= a[i].y; j++) printf("(%d,%d) ", a[i].x, j);
puts("");
}
}
int main() {
doing();
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > ans;
int cnt[2502], dp[2502];
bool vis[52][52];
int n, m, k;
vector<pair<int, int> > cur;
int res = 0;
void dfs(int i, int j, int d) {
cur.emplace_back(pair<int, int>(i, j));
vis[i][j] = 1;
if (i + 1 <= n) {
if (!vis[i + 1][j] && dp[d + 1] > 0) dfs(i + 1, j, d + 1);
}
if (j + 1 <= m) {
if (!vis[i][j + 1] && dp[d + 1] > 0) dfs(i, j + 1, d + 1);
}
ans.emplace_back(cur);
res += cur.size();
dp[d]--;
cur.pop_back();
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cnt[i + j - 1]++;
int sum = 0;
for (int i = 1; i <= n + m - 1; i++) {
if (sum + cnt[i] > k) {
dp[i] = k - sum;
break;
}
dp[i] = cnt[i];
sum += cnt[i];
}
dfs(1, 1, 1);
printf("%d\n", res);
for (int i = 0; i < ans.size(); i++) {
for (int j = 0; j < ans[i].size(); j++) {
printf("(%d,%d) ", ans[i][j].first, ans[i][j].second);
}
printf("\n");
}
}
|
### Prompt
Your task is to create a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > ans;
int cnt[2502], dp[2502];
bool vis[52][52];
int n, m, k;
vector<pair<int, int> > cur;
int res = 0;
void dfs(int i, int j, int d) {
cur.emplace_back(pair<int, int>(i, j));
vis[i][j] = 1;
if (i + 1 <= n) {
if (!vis[i + 1][j] && dp[d + 1] > 0) dfs(i + 1, j, d + 1);
}
if (j + 1 <= m) {
if (!vis[i][j + 1] && dp[d + 1] > 0) dfs(i, j + 1, d + 1);
}
ans.emplace_back(cur);
res += cur.size();
dp[d]--;
cur.pop_back();
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cnt[i + j - 1]++;
int sum = 0;
for (int i = 1; i <= n + m - 1; i++) {
if (sum + cnt[i] > k) {
dp[i] = k - sum;
break;
}
dp[i] = cnt[i];
sum += cnt[i];
}
dfs(1, 1, 1);
printf("%d\n", res);
for (int i = 0; i < ans.size(); i++) {
for (int j = 0; j < ans[i].size(); j++) {
printf("(%d,%d) ", ans[i][j].first, ans[i][j].second);
}
printf("\n");
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct st {
int x, y;
} s[25010];
bool cmp(st a, st b) { return a.x + a.y < b.x + b.y; }
int w, n, m, k, ans;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) s[w].x = i, s[w].y = j, w++;
sort(s, s + w, cmp);
for (int i = k - 1; i >= 0; i--) ans = ans + s[i].x - 1 + s[i].y;
cout << ans << '\n';
for (int i = k - 1; i >= 0; i--) {
for (int j = 1; j < s[i].y; j++) cout << "(1," << j << ")";
for (int j = 1; j <= s[i].x; j++) cout << "(" << j << "," << s[i].y << ") ";
cout << '\n';
}
}
|
### Prompt
Create a solution in Cpp for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct st {
int x, y;
} s[25010];
bool cmp(st a, st b) { return a.x + a.y < b.x + b.y; }
int w, n, m, k, ans;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) s[w].x = i, s[w].y = j, w++;
sort(s, s + w, cmp);
for (int i = k - 1; i >= 0; i--) ans = ans + s[i].x - 1 + s[i].y;
cout << ans << '\n';
for (int i = k - 1; i >= 0; i--) {
for (int j = 1; j < s[i].y; j++) cout << "(1," << j << ")";
for (int j = 1; j <= s[i].x; j++) cout << "(" << j << "," << s[i].y << ") ";
cout << '\n';
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
int MAX = 1000000;
int MIN = -1000000;
int INF = 1000000000;
int x4[4] = {0, 1, 0, -1};
int y4[4] = {1, 0, -1, 0};
int x8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int y8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
int i, j, k;
bool cmp(pair<int, int> A, pair<int, int> B) {
int a1 = A.first;
int a2 = A.second;
int b1 = B.first;
int b2 = B.second;
if (a1 + a2 != b1 + b2)
return a1 + a2 < b1 + b2;
else
return a1 * a2 < b1 * b2;
}
int main() {
int n, m, k, sum = 0;
vector<pair<int, int> > v;
cin >> n >> m >> k;
for (i = (1); i < (n + 1); i++) {
for (j = (1); j < (m + 1); j++) v.push_back(pair<int, int>(i, j));
}
sort(v.begin(), v.end(), cmp);
vector<pair<int, int> > ambil, ans;
for (i = (0); i < (k); i++) ambil.push_back(v[i]);
for (i = (0); i < (k); i++)
sum += (ambil[i].first - 1) + (ambil[i].second - 1);
cout << sum + k << endl;
for (int i = ambil.size() - 1; i >= 0; i--) {
int X = ambil[i].first;
int Y = ambil[i].second;
ans.clear();
for (int x = 1; x <= X; x++) ans.push_back(pair<int, int>(x, 1));
for (int y = 2; y <= Y; y++) ans.push_back(pair<int, int>(X, y));
for (int j = 0; j < ans.size(); j++)
cout << "(" << ans[j].first << "," << ans[j].second << ") ";
cout << endl;
}
return 0;
}
|
### Prompt
Develop a solution in CPP to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int MAX = 1000000;
int MIN = -1000000;
int INF = 1000000000;
int x4[4] = {0, 1, 0, -1};
int y4[4] = {1, 0, -1, 0};
int x8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int y8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
int i, j, k;
bool cmp(pair<int, int> A, pair<int, int> B) {
int a1 = A.first;
int a2 = A.second;
int b1 = B.first;
int b2 = B.second;
if (a1 + a2 != b1 + b2)
return a1 + a2 < b1 + b2;
else
return a1 * a2 < b1 * b2;
}
int main() {
int n, m, k, sum = 0;
vector<pair<int, int> > v;
cin >> n >> m >> k;
for (i = (1); i < (n + 1); i++) {
for (j = (1); j < (m + 1); j++) v.push_back(pair<int, int>(i, j));
}
sort(v.begin(), v.end(), cmp);
vector<pair<int, int> > ambil, ans;
for (i = (0); i < (k); i++) ambil.push_back(v[i]);
for (i = (0); i < (k); i++)
sum += (ambil[i].first - 1) + (ambil[i].second - 1);
cout << sum + k << endl;
for (int i = ambil.size() - 1; i >= 0; i--) {
int X = ambil[i].first;
int Y = ambil[i].second;
ans.clear();
for (int x = 1; x <= X; x++) ans.push_back(pair<int, int>(x, 1));
for (int y = 2; y <= Y; y++) ans.push_back(pair<int, int>(X, y));
for (int j = 0; j < ans.size(); j++)
cout << "(" << ans[j].first << "," << ans[j].second << ") ";
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int goal[101];
vector<vector<pair<int, int> > > res;
vector<pair<int, int> > vs;
vector<pair<int, int> > wtf;
void go(int x, int y, int goal) {
vs.push_back(pair<int, int>(x, y));
if (y == goal) {
res.push_back(vs);
vs.pop_back();
return;
}
go(x, y + 1, goal);
res.push_back(vs);
vs.pop_back();
}
int main() {
scanf("%d %d %d", &n, &m, &k);
int to;
bool flag = false;
if (m > n) flag = true, swap(n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
wtf.push_back(pair<int, int>(i, j));
}
}
sort(wtf.begin(), wtf.end(), [](pair<int, int> a, pair<int, int> b) {
return a.first + a.second < b.first + b.second;
});
to = 0;
int cnt = 0;
memset(goal, -1, sizeof(goal));
while (cnt < k) {
pair<int, int> p = *wtf.begin();
wtf.erase(wtf.begin());
cnt++;
goal[p.first] = p.second;
to = max(to, p.first);
}
for (int i = 0; i <= to; i++) vs.push_back(pair<int, int>(i, 0));
for (int i = to; i >= 0; i--) {
vs.pop_back();
if (goal[i] >= 0) go(i, 0, goal[i]);
}
int tot = 0;
for (int i = 0; i < (int)res.size(); i++) {
tot += (int)res[i].size();
}
printf("%d\n", tot);
for (int i = 0; i < (int)res.size(); i++) {
for (int j = 0; j < (int)res[i].size(); j++) {
if (flag) swap(res[i][j].first, res[i][j].second);
printf("(%d,%d) ", res[i][j].first + 1, res[i][j].second + 1);
}
puts("");
}
return 0;
}
|
### Prompt
In CPP, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int goal[101];
vector<vector<pair<int, int> > > res;
vector<pair<int, int> > vs;
vector<pair<int, int> > wtf;
void go(int x, int y, int goal) {
vs.push_back(pair<int, int>(x, y));
if (y == goal) {
res.push_back(vs);
vs.pop_back();
return;
}
go(x, y + 1, goal);
res.push_back(vs);
vs.pop_back();
}
int main() {
scanf("%d %d %d", &n, &m, &k);
int to;
bool flag = false;
if (m > n) flag = true, swap(n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
wtf.push_back(pair<int, int>(i, j));
}
}
sort(wtf.begin(), wtf.end(), [](pair<int, int> a, pair<int, int> b) {
return a.first + a.second < b.first + b.second;
});
to = 0;
int cnt = 0;
memset(goal, -1, sizeof(goal));
while (cnt < k) {
pair<int, int> p = *wtf.begin();
wtf.erase(wtf.begin());
cnt++;
goal[p.first] = p.second;
to = max(to, p.first);
}
for (int i = 0; i <= to; i++) vs.push_back(pair<int, int>(i, 0));
for (int i = to; i >= 0; i--) {
vs.pop_back();
if (goal[i] >= 0) go(i, 0, goal[i]);
}
int tot = 0;
for (int i = 0; i < (int)res.size(); i++) {
tot += (int)res[i].size();
}
printf("%d\n", tot);
for (int i = 0; i < (int)res.size(); i++) {
for (int j = 0; j < (int)res[i].size(); j++) {
if (flag) swap(res[i][j].first, res[i][j].second);
printf("(%d,%d) ", res[i][j].first + 1, res[i][j].second + 1);
}
puts("");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
vector<pair<int, pair<int, int> > > v;
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int(i) = 0; (i) < (N); (i)++)
for (int(j) = 0; (j) < (M); (j)++)
v.push_back(make_pair(i + j + 1, make_pair(i + 1, j + 1)));
sort((v).begin(), (v).end());
int ans = 0;
for (int i = K - 1; i >= 0; i--) ans += v[i].first;
printf("%d\n", ans);
for (int i = K - 1; i >= 0; i--) {
int px = 1, py = 1;
bool fs = false;
while (px <= v[i].second.first) {
if (fs) putchar(' ');
fs = true;
printf("(%d,%d)", px, py);
px++;
}
px--;
py++;
while (py <= v[i].second.second) {
if (fs) putchar(' ');
fs = true;
printf("(%d,%d)", px, py);
py++;
}
putchar('\n');
}
}
|
### Prompt
Please formulate a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
vector<pair<int, pair<int, int> > > v;
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int(i) = 0; (i) < (N); (i)++)
for (int(j) = 0; (j) < (M); (j)++)
v.push_back(make_pair(i + j + 1, make_pair(i + 1, j + 1)));
sort((v).begin(), (v).end());
int ans = 0;
for (int i = K - 1; i >= 0; i--) ans += v[i].first;
printf("%d\n", ans);
for (int i = K - 1; i >= 0; i--) {
int px = 1, py = 1;
bool fs = false;
while (px <= v[i].second.first) {
if (fs) putchar(' ');
fs = true;
printf("(%d,%d)", px, py);
px++;
}
px--;
py++;
while (py <= v[i].second.second) {
if (fs) putchar(' ');
fs = true;
printf("(%d,%d)", px, py);
py++;
}
putchar('\n');
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize "Ofast"
#pragma GCC optimize "fast-math"
#pragma GCC optimize "no-stack-protector"
long long INF = (long long)1e20;
int iINF = (int)1e20;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
long long d[n][m];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) d[i][j] = INF;
d[0][0] = 1;
long long done = 0;
vector<pair<long long, long long>> vc;
queue<pair<long long, long long>> q;
vector<pair<long long, long long>> dd = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
q.push({0, 0});
long long ans = 0;
while (done < k) {
++done;
vc.push_back(q.front());
pair<long long, long long> now = q.front();
q.pop();
ans += d[now.first][now.second];
for (int i = 0; i < 4; ++i) {
long long x = now.first + dd[i].first;
long long y = now.second + dd[i].second;
if (x >= 0 and y >= 0 and x < n and y < m) {
if (d[x][y] > d[now.first][now.second] + 1) {
d[x][y] = d[now.first][now.second] + 1;
q.push({x, y});
}
}
}
}
cout << ans << '\n';
reverse(vc.begin(), vc.end());
for (int i = 0; i < vc.size(); ++i) {
if (vc[i].first != 0)
for (int j = 0; j < vc[i].first + 1; ++j) cout << "(" << j + 1 << ", 1) ";
if (vc[i].second != 0)
for (int j = 0; j < vc[i].second + 1; ++j) {
if (vc[i].first != 0 and j == 0) continue;
cout << "(" << vc[i].first + 1 << ", " << j + 1 << ") ";
}
if (i == vc.size() - 1) cout << "(1, 1)";
cout << '\n';
}
}
|
### Prompt
In Cpp, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize "Ofast"
#pragma GCC optimize "fast-math"
#pragma GCC optimize "no-stack-protector"
long long INF = (long long)1e20;
int iINF = (int)1e20;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
long long d[n][m];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) d[i][j] = INF;
d[0][0] = 1;
long long done = 0;
vector<pair<long long, long long>> vc;
queue<pair<long long, long long>> q;
vector<pair<long long, long long>> dd = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
q.push({0, 0});
long long ans = 0;
while (done < k) {
++done;
vc.push_back(q.front());
pair<long long, long long> now = q.front();
q.pop();
ans += d[now.first][now.second];
for (int i = 0; i < 4; ++i) {
long long x = now.first + dd[i].first;
long long y = now.second + dd[i].second;
if (x >= 0 and y >= 0 and x < n and y < m) {
if (d[x][y] > d[now.first][now.second] + 1) {
d[x][y] = d[now.first][now.second] + 1;
q.push({x, y});
}
}
}
}
cout << ans << '\n';
reverse(vc.begin(), vc.end());
for (int i = 0; i < vc.size(); ++i) {
if (vc[i].first != 0)
for (int j = 0; j < vc[i].first + 1; ++j) cout << "(" << j + 1 << ", 1) ";
if (vc[i].second != 0)
for (int j = 0; j < vc[i].second + 1; ++j) {
if (vc[i].first != 0 and j == 0) continue;
cout << "(" << vc[i].first + 1 << ", " << j + 1 << ") ";
}
if (i == vc.size() - 1) cout << "(1, 1)";
cout << '\n';
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
signed long long GETi() {
signed long long i;
scanf("%lld", &i);
return i;
}
int H, W, K;
void solve() {
int f, i, j, k, l, x, y;
cin >> H >> W >> K;
int r = 0;
vector<pair<int, int> > V;
for (l = 1; l <= H + W - 1; l++) {
for (y = 0; y < H; y++) {
int x = (l - 1) - y;
if (x < 0 || x >= W) continue;
if (K-- == 0) goto out;
r += l;
V.push_back(make_pair(x, y));
}
}
out:
(void)printf("%d\n", r);
for (i = 0; i < V.size(); i++) {
int tx = V[V.size() - 1 - i].first + 1;
int ty = V[V.size() - 1 - i].second + 1;
x = 1;
y = 1;
while (y < ty) (void)printf("(%d,%d) ", y, x), y++;
while (x <= tx) (void)printf("(%d,%d) ", y, x), x++;
(void)printf("\n");
}
}
int main(int argc, char** argv) {
string s;
if (argc == 1) ios::sync_with_stdio(false);
for (int i = 1; i < argc; i++) s += argv[i], s += '\n';
for (int i = s.size() - 1; i >= 0; i--) ungetc(s[i], stdin);
solve();
return 0;
}
|
### Prompt
Create a solution in Cpp for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
signed long long GETi() {
signed long long i;
scanf("%lld", &i);
return i;
}
int H, W, K;
void solve() {
int f, i, j, k, l, x, y;
cin >> H >> W >> K;
int r = 0;
vector<pair<int, int> > V;
for (l = 1; l <= H + W - 1; l++) {
for (y = 0; y < H; y++) {
int x = (l - 1) - y;
if (x < 0 || x >= W) continue;
if (K-- == 0) goto out;
r += l;
V.push_back(make_pair(x, y));
}
}
out:
(void)printf("%d\n", r);
for (i = 0; i < V.size(); i++) {
int tx = V[V.size() - 1 - i].first + 1;
int ty = V[V.size() - 1 - i].second + 1;
x = 1;
y = 1;
while (y < ty) (void)printf("(%d,%d) ", y, x), y++;
while (x <= tx) (void)printf("(%d,%d) ", y, x), x++;
(void)printf("\n");
}
}
int main(int argc, char** argv) {
string s;
if (argc == 1) ios::sync_with_stdio(false);
for (int i = 1; i < argc; i++) s += argv[i], s += '\n';
for (int i = s.size() - 1; i >= 0; i--) ungetc(s[i], stdin);
solve();
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > paths;
bool comp(pair<int, int>& a, pair<int, int>& b) {
return a.first + a.second < b.first + b.second;
}
vector<pair<int, int> > get_path(pair<int, int> square) {
vector<pair<int, int> > path;
int i = 1;
int j = 1;
while (i < square.first) {
path.push_back({i, j});
i++;
}
while (j < square.second) {
path.push_back({i, j});
j++;
}
path.push_back(square);
return path;
}
int main(void) {
int n, m, k;
vector<pair<int, int> > squares;
scanf(" %d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
squares.push_back({i, j});
}
}
sort(squares.begin(), squares.end(), comp);
int ans = 0;
for (int i = k - 1; i >= 0; i--) {
paths.push_back(get_path(squares[i]));
ans += paths.back().size();
}
printf("%d\n", ans);
for (int i = 0; i < (int)paths.size(); i++) {
for (int j = 0; j < (int)paths[i].size(); j++) {
if (j != 0) {
printf(" ");
}
printf("(%d,%d)", paths[i][j].first, paths[i][j].second);
}
printf("\n");
}
return 0;
}
|
### Prompt
Generate a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > paths;
bool comp(pair<int, int>& a, pair<int, int>& b) {
return a.first + a.second < b.first + b.second;
}
vector<pair<int, int> > get_path(pair<int, int> square) {
vector<pair<int, int> > path;
int i = 1;
int j = 1;
while (i < square.first) {
path.push_back({i, j});
i++;
}
while (j < square.second) {
path.push_back({i, j});
j++;
}
path.push_back(square);
return path;
}
int main(void) {
int n, m, k;
vector<pair<int, int> > squares;
scanf(" %d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
squares.push_back({i, j});
}
}
sort(squares.begin(), squares.end(), comp);
int ans = 0;
for (int i = k - 1; i >= 0; i--) {
paths.push_back(get_path(squares[i]));
ans += paths.back().size();
}
printf("%d\n", ans);
for (int i = 0; i < (int)paths.size(); i++) {
for (int j = 0; j < (int)paths[i].size(); j++) {
if (j != 0) {
printf(" ");
}
printf("(%d,%d)", paths[i][j].first, paths[i][j].second);
}
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace ::std;
const long double PI = acos(-1);
const int MOD = 1000000000 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int add(long long a, long long b) {
return (a % MOD + b % MOD + 2 * MOD) % MOD;
}
int mul(long long a, long long b) {
return ((a % MOD + MOD) * (b % MOD + MOD)) % MOD;
}
long long pow_mod(long long a, long long b) {
long long res = 1LL;
a = add(a, 0);
while (b) {
if (b & 1) res = mul(res, a);
b >>= 1;
a = mul(a, a);
}
return res;
}
long long fastexp(long long a, long long b) {
long long res = 1LL;
while (b) {
if (b & 1) res = res * a;
b >>= 1;
a *= a;
}
return res;
}
int gcdExtendido(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtendido(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
};
int modInverso(int a, int m) {
int x, y;
int g = gcdExtendido(a, m, &x, &y);
if (g != 1)
return -1;
else
return (x % m + m) % m;
}
const int N = 55;
int n, m, k;
int v[N][N];
bool vis[N][N];
vector<pair<int, pair<int, int> > > positions;
vector<vector<int> > answer;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int parentx[N][N];
int parenty[N][N];
bool validPos(int i, int j) { return i >= 0 and j >= 0 and i < n and j < m; }
void BFS(int sx, int sy) {
queue<int> Q;
Q.push(sx);
Q.push(sy);
Q.push(0);
v[sx][sy] = 0;
vis[sx][sy] = true;
positions.push_back(make_pair(v[sx][sy], make_pair(sx, sy)));
while (!Q.empty()) {
int ux = Q.front();
Q.pop();
int uy = Q.front();
Q.pop();
int d = Q.front();
Q.pop();
for (int i = 0; i < 4; i++) {
int vx = ux + dx[i];
int vy = uy + dy[i];
if (validPos(vx, vy) and !vis[vx][vy]) {
v[vx][vy] = d + 1;
vis[vx][vy] = true;
Q.push(vx);
Q.push(vy);
Q.push(d + 1);
positions.push_back(make_pair(d + 1, make_pair(vx, vy)));
parentx[vx][vy] = ux;
parenty[vx][vy] = uy;
}
}
}
}
bool comp(pair<int, pair<int, int> > &a, pair<int, pair<int, int> > &b) {
return a.first < b.first;
}
int main() {
scanf("%d %d %d", &(n), &(m), &(k));
BFS(0, 0);
sort((positions).begin(), (positions).end(), comp);
stack<int> S;
int ans = 0;
for (int i = k - 1; i >= 0; i--) {
int x = positions[i].second.first;
int y = positions[i].second.second;
vector<int> c;
while (x != 0 or y != 0) {
S.push(y + 1);
S.push(x + 1);
int carryx = parentx[x][y];
int carryy = parenty[x][y];
x = carryx;
y = carryy;
ans += 1;
}
S.push(1);
S.push(1);
ans += 1;
while (!S.empty()) {
c.push_back(S.top());
S.pop();
}
answer.push_back(c);
}
cout << ans << endl;
for (int i = 0; i < answer.size(); i++) {
for (int j = 0; j < answer[i].size(); j += 2) {
printf("(%d,%d) ", answer[i][j], answer[i][j + 1]);
}
puts("");
}
return 0;
}
|
### Prompt
In CPP, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace ::std;
const long double PI = acos(-1);
const int MOD = 1000000000 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int add(long long a, long long b) {
return (a % MOD + b % MOD + 2 * MOD) % MOD;
}
int mul(long long a, long long b) {
return ((a % MOD + MOD) * (b % MOD + MOD)) % MOD;
}
long long pow_mod(long long a, long long b) {
long long res = 1LL;
a = add(a, 0);
while (b) {
if (b & 1) res = mul(res, a);
b >>= 1;
a = mul(a, a);
}
return res;
}
long long fastexp(long long a, long long b) {
long long res = 1LL;
while (b) {
if (b & 1) res = res * a;
b >>= 1;
a *= a;
}
return res;
}
int gcdExtendido(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtendido(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
};
int modInverso(int a, int m) {
int x, y;
int g = gcdExtendido(a, m, &x, &y);
if (g != 1)
return -1;
else
return (x % m + m) % m;
}
const int N = 55;
int n, m, k;
int v[N][N];
bool vis[N][N];
vector<pair<int, pair<int, int> > > positions;
vector<vector<int> > answer;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int parentx[N][N];
int parenty[N][N];
bool validPos(int i, int j) { return i >= 0 and j >= 0 and i < n and j < m; }
void BFS(int sx, int sy) {
queue<int> Q;
Q.push(sx);
Q.push(sy);
Q.push(0);
v[sx][sy] = 0;
vis[sx][sy] = true;
positions.push_back(make_pair(v[sx][sy], make_pair(sx, sy)));
while (!Q.empty()) {
int ux = Q.front();
Q.pop();
int uy = Q.front();
Q.pop();
int d = Q.front();
Q.pop();
for (int i = 0; i < 4; i++) {
int vx = ux + dx[i];
int vy = uy + dy[i];
if (validPos(vx, vy) and !vis[vx][vy]) {
v[vx][vy] = d + 1;
vis[vx][vy] = true;
Q.push(vx);
Q.push(vy);
Q.push(d + 1);
positions.push_back(make_pair(d + 1, make_pair(vx, vy)));
parentx[vx][vy] = ux;
parenty[vx][vy] = uy;
}
}
}
}
bool comp(pair<int, pair<int, int> > &a, pair<int, pair<int, int> > &b) {
return a.first < b.first;
}
int main() {
scanf("%d %d %d", &(n), &(m), &(k));
BFS(0, 0);
sort((positions).begin(), (positions).end(), comp);
stack<int> S;
int ans = 0;
for (int i = k - 1; i >= 0; i--) {
int x = positions[i].second.first;
int y = positions[i].second.second;
vector<int> c;
while (x != 0 or y != 0) {
S.push(y + 1);
S.push(x + 1);
int carryx = parentx[x][y];
int carryy = parenty[x][y];
x = carryx;
y = carryy;
ans += 1;
}
S.push(1);
S.push(1);
ans += 1;
while (!S.empty()) {
c.push_back(S.top());
S.pop();
}
answer.push_back(c);
}
cout << ans << endl;
for (int i = 0; i < answer.size(); i++) {
for (int j = 0; j < answer[i].size(); j += 2) {
printf("(%d,%d) ", answer[i][j], answer[i][j + 1]);
}
puts("");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
int dist, x, y;
operator int() const { return dist; }
bool operator<(const Point &b) const { return int(*this) < int(b); }
void out() { printf("(%d,%d) ", x, y); }
};
int n, m, k;
vector<Point> p;
void EXEC() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) p.push_back({i + j - 1, i, j});
partial_sort(p.begin(), p.begin() + k, p.end());
p.erase(p.begin() + k, p.end());
reverse(p.begin(), p.end());
cout << accumulate(p.begin(), p.end(), 0) << endl;
for (auto i : p) {
Point t = {0, 1, 1};
t.out();
while (t.x < i.x) {
++t.x;
t.out();
}
while (t.y < i.y) {
++t.y;
t.out();
}
cout << endl;
}
}
int main() {
EXEC();
return 0;
}
|
### Prompt
Generate a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Point {
int dist, x, y;
operator int() const { return dist; }
bool operator<(const Point &b) const { return int(*this) < int(b); }
void out() { printf("(%d,%d) ", x, y); }
};
int n, m, k;
vector<Point> p;
void EXEC() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) p.push_back({i + j - 1, i, j});
partial_sort(p.begin(), p.begin() + k, p.end());
p.erase(p.begin() + k, p.end());
reverse(p.begin(), p.end());
cout << accumulate(p.begin(), p.end(), 0) << endl;
for (auto i : p) {
Point t = {0, 1, 1};
t.out();
while (t.x < i.x) {
++t.x;
t.out();
}
while (t.y < i.y) {
++t.y;
t.out();
}
cout << endl;
}
}
int main() {
EXEC();
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y, val;
};
int n, m, k, ccnt, ans;
point cur, pos;
vector<pair<int, int> > way[2501];
int new_val(int x, int y) { return min(y, n - x + 1); }
void change(int type) {
if (type == 1) {
if (cur.y < m)
cur.y++;
else
cur.x++;
cur.val = new_val(cur.x, cur.y);
} else {
if (cur.x > 1)
cur.x--;
else
cur.y--;
cur.val = new_val(cur.x, cur.y);
}
}
int main() {
cin >> n >> m >> k;
cur.x = cur.y = cur.val = 1;
int cnt = 1;
while (cnt < k) {
change(1);
cnt += cur.val;
}
cnt -= cur.val;
pos.x = cur.x;
pos.y = cur.y;
while (cnt) {
if (cnt == k - ccnt) {
change(-1);
cnt -= cur.val;
pos.x = cur.x;
pos.y = cur.y;
}
for (int i = 1; i < pos.y; ++i) way[ccnt].push_back(make_pair(1, i));
for (int i = 1; i <= pos.x; ++i) way[ccnt].push_back(make_pair(i, pos.y));
pos.y--;
pos.x++;
ccnt++;
ans += cur.y - 1 + cur.x;
}
if (k == 1) {
ans++;
way[0].push_back(make_pair(1, 1));
ccnt++;
}
cout << ans << endl;
for (int i = 0; i < ccnt; ++i) {
for (int j = 0; j < (int)(way[i].size()); ++j) {
cout << '(' << way[i][j].first << ", " << way[i][j].second << ")";
if (j < (int)(way[i].size()) - 1) cout << ' ';
}
if (i < ccnt - 1) cout << endl;
}
}
|
### Prompt
Create a solution in CPP for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y, val;
};
int n, m, k, ccnt, ans;
point cur, pos;
vector<pair<int, int> > way[2501];
int new_val(int x, int y) { return min(y, n - x + 1); }
void change(int type) {
if (type == 1) {
if (cur.y < m)
cur.y++;
else
cur.x++;
cur.val = new_val(cur.x, cur.y);
} else {
if (cur.x > 1)
cur.x--;
else
cur.y--;
cur.val = new_val(cur.x, cur.y);
}
}
int main() {
cin >> n >> m >> k;
cur.x = cur.y = cur.val = 1;
int cnt = 1;
while (cnt < k) {
change(1);
cnt += cur.val;
}
cnt -= cur.val;
pos.x = cur.x;
pos.y = cur.y;
while (cnt) {
if (cnt == k - ccnt) {
change(-1);
cnt -= cur.val;
pos.x = cur.x;
pos.y = cur.y;
}
for (int i = 1; i < pos.y; ++i) way[ccnt].push_back(make_pair(1, i));
for (int i = 1; i <= pos.x; ++i) way[ccnt].push_back(make_pair(i, pos.y));
pos.y--;
pos.x++;
ccnt++;
ans += cur.y - 1 + cur.x;
}
if (k == 1) {
ans++;
way[0].push_back(make_pair(1, 1));
ccnt++;
}
cout << ans << endl;
for (int i = 0; i < ccnt; ++i) {
for (int j = 0; j < (int)(way[i].size()); ++j) {
cout << '(' << way[i][j].first << ", " << way[i][j].second << ")";
if (j < (int)(way[i].size()) - 1) cout << ' ';
}
if (i < ccnt - 1) cout << endl;
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
bool mark[5000][5000];
vector<pair<int, int> > ans[100000];
int main() {
int n, m, k;
cin >> n >> m >> k;
int sum = 0, t = k;
for (int i = 1; i <= m * n; i++)
for (int j = 1; j <= i; j++) {
if (k == 0) break;
if (i - j + 1 > n || j > m) continue;
k--;
int t = i - j + 1;
for (int l = 1; l <= j; l++) ans[k].push_back(make_pair(1, l));
for (int l = 2; l <= t; l++) ans[k].push_back(make_pair(l, j));
sum += i;
}
cout << sum << endl;
for (int i = 0; i < t; i++, cout << endl)
for (int j = 0; j < ans[i].size(); j++)
cout << '(' << ans[i][j].first << ',' << ans[i][j].second << ") ";
return 0;
}
|
### Prompt
Please create a solution in cpp to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool mark[5000][5000];
vector<pair<int, int> > ans[100000];
int main() {
int n, m, k;
cin >> n >> m >> k;
int sum = 0, t = k;
for (int i = 1; i <= m * n; i++)
for (int j = 1; j <= i; j++) {
if (k == 0) break;
if (i - j + 1 > n || j > m) continue;
k--;
int t = i - j + 1;
for (int l = 1; l <= j; l++) ans[k].push_back(make_pair(1, l));
for (int l = 2; l <= t; l++) ans[k].push_back(make_pair(l, j));
sum += i;
}
cout << sum << endl;
for (int i = 0; i < t; i++, cout << endl)
for (int j = 0; j < ans[i].size(); j++)
cout << '(' << ans[i][j].first << ',' << ans[i][j].second << ") ";
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4000009;
int n, m, k;
int ans;
vector<pair<int, pair<int, int> > > matrix;
void xuat(int x, int y) { cout << "(" << x << "," << y << ") "; }
void go(pair<int, int> start, pair<int, int> finish) {
xuat(start.first, start.second);
while (start.first != finish.first) {
start.first++;
xuat(start.first, start.second);
}
while (start.second != finish.second) {
start.second++;
xuat(start.first, start.second);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
matrix.push_back(make_pair(i + j, make_pair(i, j)));
}
}
sort(matrix.begin(), matrix.end());
for (int i = 0; i < k; i++) {
ans += matrix[i].first - matrix[0].first + 1;
}
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
go(matrix[0].second, matrix[i].second);
cout << endl;
}
return 0;
}
|
### Prompt
Your task is to create a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 4000009;
int n, m, k;
int ans;
vector<pair<int, pair<int, int> > > matrix;
void xuat(int x, int y) { cout << "(" << x << "," << y << ") "; }
void go(pair<int, int> start, pair<int, int> finish) {
xuat(start.first, start.second);
while (start.first != finish.first) {
start.first++;
xuat(start.first, start.second);
}
while (start.second != finish.second) {
start.second++;
xuat(start.first, start.second);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
matrix.push_back(make_pair(i + j, make_pair(i, j)));
}
}
sort(matrix.begin(), matrix.end());
for (int i = 0; i < k; i++) {
ans += matrix[i].first - matrix[0].first + 1;
}
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
go(matrix[0].second, matrix[i].second);
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 123;
vector<pair<int, int> > d[mx];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) d[i + j].push_back(make_pair(i, j));
int ans = 0;
vector<pair<int, int> > target;
for (int i = 0; i < mx && k > 0; i++) {
for (int j = 0; j < int(d[i].size()) && k > 0; j++) {
k--;
target.push_back(d[i][j]);
ans += i + 1;
}
}
printf("%d\n", ans);
reverse(target.begin(), target.end());
for (auto p : target) {
printf("(1,1)");
int r = 0, c = 0;
while (r < p.first) {
r++;
printf(" (%d,%d)", r + 1, c + 1);
}
while (c < p.second) {
c++;
printf(" (%d,%d)", r + 1, c + 1);
}
puts("");
}
return 0;
}
|
### Prompt
Create a solution in cpp for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mx = 123;
vector<pair<int, int> > d[mx];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) d[i + j].push_back(make_pair(i, j));
int ans = 0;
vector<pair<int, int> > target;
for (int i = 0; i < mx && k > 0; i++) {
for (int j = 0; j < int(d[i].size()) && k > 0; j++) {
k--;
target.push_back(d[i][j]);
ans += i + 1;
}
}
printf("%d\n", ans);
reverse(target.begin(), target.end());
for (auto p : target) {
printf("(1,1)");
int r = 0, c = 0;
while (r < p.first) {
r++;
printf(" (%d,%d)", r + 1, c + 1);
}
while (c < p.second) {
c++;
printf(" (%d,%d)", r + 1, c + 1);
}
puts("");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct tt {
int x, y;
} a[3000];
int cmp(tt x, tt y) { return (x.x + x.y) < (y.x + y.y); }
int main() {
int n, m, k;
cin >> n >> m >> k;
int id = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[id].x = i, a[id].y = j, id++;
int nn = n * m;
sort(a, a + nn, cmp);
int ans = 0;
for (int i = 0; i < k; i++) {
ans += (a[i].x + a[i].y - 1);
}
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
int xx = 1, yy = 1, yi = 0;
while (xx <= a[i].x && yy <= a[i].y) {
if (yi) printf(" ");
yi = 1;
printf("(%d,%d)", xx, yy);
if (xx < a[i].x)
xx++;
else if (yy < a[i].y)
yy++;
else if (xx == a[i].x && yy == a[i].y)
break;
}
puts("");
}
return 0;
}
|
### Prompt
Please formulate a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct tt {
int x, y;
} a[3000];
int cmp(tt x, tt y) { return (x.x + x.y) < (y.x + y.y); }
int main() {
int n, m, k;
cin >> n >> m >> k;
int id = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[id].x = i, a[id].y = j, id++;
int nn = n * m;
sort(a, a + nn, cmp);
int ans = 0;
for (int i = 0; i < k; i++) {
ans += (a[i].x + a[i].y - 1);
}
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
int xx = 1, yy = 1, yi = 0;
while (xx <= a[i].x && yy <= a[i].y) {
if (yi) printf(" ");
yi = 1;
printf("(%d,%d)", xx, yy);
if (xx < a[i].x)
xx++;
else if (yy < a[i].y)
yy++;
else if (xx == a[i].x && yy == a[i].y)
break;
}
puts("");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 123;
const int mod = 1e9 + 7;
const int INF = 1e9 + 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
vector<pair<int, int> > v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k, sum = 0;
cin >> n >> m >> k;
for (int num = 2; num <= n + m; num++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i + j == num) {
k--;
v.push_back(make_pair(i, j));
}
if (!k) goto h;
}
}
}
h:;
for (auto i : v) {
sum += (i.first + i.second - 1);
}
cout << sum << endl;
for (int i = v.size() - 1; i >= 0; i--) {
int x = 1, y = 0;
while (y != v[i].second) {
y++;
cout << "(1," << y << ") ";
}
while (x != v[i].first) {
x++;
cout << "(" << x << ',' << y << ") ";
}
cout << endl;
}
return 0;
}
|
### Prompt
Create a solution in Cpp for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 123;
const int mod = 1e9 + 7;
const int INF = 1e9 + 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
vector<pair<int, int> > v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k, sum = 0;
cin >> n >> m >> k;
for (int num = 2; num <= n + m; num++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i + j == num) {
k--;
v.push_back(make_pair(i, j));
}
if (!k) goto h;
}
}
}
h:;
for (auto i : v) {
sum += (i.first + i.second - 1);
}
cout << sum << endl;
for (int i = v.size() - 1; i >= 0; i--) {
int x = 1, y = 0;
while (y != v[i].second) {
y++;
cout << "(1," << y << ") ";
}
while (x != v[i].first) {
x++;
cout << "(" << x << ',' << y << ") ";
}
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:252457298")
#pragma GCC optimize("Ofast")
using namespace std;
mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count());
int n, m, k;
int dx[] = {-1, +0, +0, +1};
int dy[] = {+0, -1, +1, +0};
pair<int, int> Default = {-1, -1};
vector<vector<int>> Dist;
vector<vector<pair<int, int>>> Last;
stack<pair<int, int>> Cells;
void Input() {
cin >> n >> m >> k;
Dist.resize(n + 2, vector<int>(m + 2, 4444));
Last.resize(n + 2, vector<pair<int, int>>(m + 2, Default));
}
void Solve() {
int cost = 0;
queue<pair<int, int>> Q;
Q.push({1, 1});
Dist[1][1] = 1;
while (!Q.empty() && Cells.size() < k) {
pair<int, int> C = Q.front();
Q.pop();
Cells.push(C);
int x = C.first, y = C.second;
cost += Dist[x][y];
for (int dir = 0; dir < 4; dir++) {
if (x + dx[dir] < 1 || x + dx[dir] > n) continue;
if (y + dy[dir] < 1 || y + dy[dir] > m) continue;
if (Dist[x + dx[dir]][y + dy[dir]] != 4444) continue;
Dist[x + dx[dir]][y + dy[dir]] = Dist[x][y] + 1;
Q.push({x + dx[dir], y + dy[dir]});
Last[x + dx[dir]][y + dy[dir]] = C;
}
}
cout << cost << '\n';
while (!Cells.empty()) {
stack<pair<int, int>> Traceback;
int x = Cells.top().first, y = Cells.top().second;
Cells.pop();
while (x != -1 && y != -1) {
Traceback.push({x, y});
pair<int, int> NextCell = Last[x][y];
x = NextCell.first;
y = NextCell.second;
}
while (!Traceback.empty()) {
pair<int, int> CurCell = Traceback.top();
Traceback.pop();
cout << "(" << CurCell.first << ", " << CurCell.second << ") ";
}
cout << '\n';
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
Input();
Solve();
return 0;
}
|
### Prompt
Your task is to create a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:252457298")
#pragma GCC optimize("Ofast")
using namespace std;
mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count());
int n, m, k;
int dx[] = {-1, +0, +0, +1};
int dy[] = {+0, -1, +1, +0};
pair<int, int> Default = {-1, -1};
vector<vector<int>> Dist;
vector<vector<pair<int, int>>> Last;
stack<pair<int, int>> Cells;
void Input() {
cin >> n >> m >> k;
Dist.resize(n + 2, vector<int>(m + 2, 4444));
Last.resize(n + 2, vector<pair<int, int>>(m + 2, Default));
}
void Solve() {
int cost = 0;
queue<pair<int, int>> Q;
Q.push({1, 1});
Dist[1][1] = 1;
while (!Q.empty() && Cells.size() < k) {
pair<int, int> C = Q.front();
Q.pop();
Cells.push(C);
int x = C.first, y = C.second;
cost += Dist[x][y];
for (int dir = 0; dir < 4; dir++) {
if (x + dx[dir] < 1 || x + dx[dir] > n) continue;
if (y + dy[dir] < 1 || y + dy[dir] > m) continue;
if (Dist[x + dx[dir]][y + dy[dir]] != 4444) continue;
Dist[x + dx[dir]][y + dy[dir]] = Dist[x][y] + 1;
Q.push({x + dx[dir], y + dy[dir]});
Last[x + dx[dir]][y + dy[dir]] = C;
}
}
cout << cost << '\n';
while (!Cells.empty()) {
stack<pair<int, int>> Traceback;
int x = Cells.top().first, y = Cells.top().second;
Cells.pop();
while (x != -1 && y != -1) {
Traceback.push({x, y});
pair<int, int> NextCell = Last[x][y];
x = NextCell.first;
y = NextCell.second;
}
while (!Traceback.empty()) {
pair<int, int> CurCell = Traceback.top();
Traceback.pop();
cout << "(" << CurCell.first << ", " << CurCell.second << ") ";
}
cout << '\n';
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
Input();
Solve();
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int dis[N][N];
pair<int, int> par[N][N];
vector<pair<int, int> > adj[N + N + N];
void pre() {
queue<pair<int, int> > q;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
memset(dis, -1, sizeof dis);
dis[0][0] = 1;
q.push({0, 0});
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
for (int i = 0; i < int(4); i++) {
int nxtx = p.first + dx[i];
int nxty = p.second + dy[i];
if (nxtx < 0 || nxty < 0 || nxtx == N || nxty == N ||
dis[nxtx][nxty] != -1)
continue;
dis[nxtx][nxty] = dis[p.first][p.second] + 1;
par[nxtx][nxty] = p;
q.push({nxtx, nxty});
}
}
}
void printPath(pair<int, int> p) {
vector<pair<int, int> > path;
while (p.first + p.second) {
path.push_back(p);
p = par[p.first][p.second];
}
path.push_back({0, 0});
reverse(path.begin(), path.end());
for (auto nxt : path)
cout << "(" << nxt.first + 1 << "," << nxt.second + 1 << ") ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pre();
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(m); j++) adj[dis[i][j]].push_back({i, j});
int ans = 0;
vector<pair<int, int> > v;
for (int i = 0; i < int(200); i++) {
for (auto nxt : adj[i]) {
v.push_back(nxt);
ans += i;
k--;
if (k == 0) {
i = 205;
break;
}
}
}
cout << ans << '\n';
reverse(v.begin(), v.end());
for (auto nxt : v) printPath(nxt);
return 0;
}
|
### Prompt
Construct a Cpp code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int dis[N][N];
pair<int, int> par[N][N];
vector<pair<int, int> > adj[N + N + N];
void pre() {
queue<pair<int, int> > q;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
memset(dis, -1, sizeof dis);
dis[0][0] = 1;
q.push({0, 0});
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
for (int i = 0; i < int(4); i++) {
int nxtx = p.first + dx[i];
int nxty = p.second + dy[i];
if (nxtx < 0 || nxty < 0 || nxtx == N || nxty == N ||
dis[nxtx][nxty] != -1)
continue;
dis[nxtx][nxty] = dis[p.first][p.second] + 1;
par[nxtx][nxty] = p;
q.push({nxtx, nxty});
}
}
}
void printPath(pair<int, int> p) {
vector<pair<int, int> > path;
while (p.first + p.second) {
path.push_back(p);
p = par[p.first][p.second];
}
path.push_back({0, 0});
reverse(path.begin(), path.end());
for (auto nxt : path)
cout << "(" << nxt.first + 1 << "," << nxt.second + 1 << ") ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pre();
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(m); j++) adj[dis[i][j]].push_back({i, j});
int ans = 0;
vector<pair<int, int> > v;
for (int i = 0; i < int(200); i++) {
for (auto nxt : adj[i]) {
v.push_back(nxt);
ans += i;
k--;
if (k == 0) {
i = 205;
break;
}
}
}
cout << ans << '\n';
reverse(v.begin(), v.end());
for (auto nxt : v) printPath(nxt);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, m, k;
struct node {
int x, y;
} p[maxn];
inline bool comp(node a, node b) { return a.x + a.y < b.x + b.y; }
inline void printans(int x, int y) {
for (int i = 1; i <= x; i++) printf("(%d,1) ", i);
for (int i = 2; i <= y; i++) printf("(%d,%d) ", x, i);
cout << endl;
}
int main() {
cin >> n >> m >> k;
int t = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p[t].x = i;
p[t].y = j;
t++;
}
}
sort(p, p + t, comp);
int ans = 0;
for (int i = 0; i < k; i++) {
ans += (p[i].x + p[i].y - 1);
}
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
printans(p[i].x, p[i].y);
}
return 0;
}
|
### Prompt
Please create a solution in cpp to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, m, k;
struct node {
int x, y;
} p[maxn];
inline bool comp(node a, node b) { return a.x + a.y < b.x + b.y; }
inline void printans(int x, int y) {
for (int i = 1; i <= x; i++) printf("(%d,1) ", i);
for (int i = 2; i <= y; i++) printf("(%d,%d) ", x, i);
cout << endl;
}
int main() {
cin >> n >> m >> k;
int t = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p[t].x = i;
p[t].y = j;
t++;
}
}
sort(p, p + t, comp);
int ans = 0;
for (int i = 0; i < k; i++) {
ans += (p[i].x + p[i].y - 1);
}
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
printans(p[i].x, p[i].y);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int a, c, d, e, f, g, h, i, j, k, l, m, n;
struct node {
int x, y, cost;
} b[10005];
inline bool cmp(const node &a, const node &b) { return a.cost < b.cost; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
b[++l] = (node){i, j, i + j - 1};
}
sort(b + 1, b + 1 + n * m, cmp);
for (i = 1; i <= k; i++) h += b[i].cost;
printf("%d\n", h);
for (; k; k--) {
for (i = 1; i < b[k].x; i++) printf("(%d,%d)", i, 1);
for (i = 1; i <= b[k].y; i++) printf("(%d,%d)", b[k].x, i);
printf("\n");
}
return 0;
}
|
### Prompt
Please create a solution in Cpp to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a, c, d, e, f, g, h, i, j, k, l, m, n;
struct node {
int x, y, cost;
} b[10005];
inline bool cmp(const node &a, const node &b) { return a.cost < b.cost; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
b[++l] = (node){i, j, i + j - 1};
}
sort(b + 1, b + 1 + n * m, cmp);
for (i = 1; i <= k; i++) h += b[i].cost;
printf("%d\n", h);
for (; k; k--) {
for (i = 1; i < b[k].x; i++) printf("(%d,%d)", i, 1);
for (i = 1; i <= b[k].y; i++) printf("(%d,%d)", b[k].x, i);
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[55 * 55];
bool cmp(pair<int, int> a, pair<int, int> b) {
return a.first + a.second < b.first + b.second;
}
void print(pair<int, int> a) {
int u = a.first, v = a.second;
for (int i = 1; i <= u; i++) {
printf("(%d,%d) ", i, 1);
}
for (int i = 2; i <= v; i++) {
printf("(%d,%d) ", u, i);
}
puts("");
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p[cnt++] = pair<int, int>(i, j);
}
}
sort(p, p + cnt, cmp);
int ans = 0;
for (int i = 0; i < k; i++) ans += p[i].first + p[i].second - 1;
printf("%d\n", ans);
while (k--) {
print(p[k]);
}
return 0;
}
|
### Prompt
Create a solution in cpp for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[55 * 55];
bool cmp(pair<int, int> a, pair<int, int> b) {
return a.first + a.second < b.first + b.second;
}
void print(pair<int, int> a) {
int u = a.first, v = a.second;
for (int i = 1; i <= u; i++) {
printf("(%d,%d) ", i, 1);
}
for (int i = 2; i <= v; i++) {
printf("(%d,%d) ", u, i);
}
puts("");
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p[cnt++] = pair<int, int>(i, j);
}
}
sort(p, p + cnt, cmp);
int ans = 0;
for (int i = 0; i < k; i++) ans += p[i].first + p[i].second - 1;
printf("%d\n", ans);
while (k--) {
print(p[k]);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int hi[] = {0, 0, 1, -1};
const int hj[] = {1, -1, 0, 0};
const int N = 55;
int d[N][N], tr[N][N];
void trace(int i, int j) {
if (i != 1 || j != 1) trace(i - hi[tr[i][j]], j - hj[tr[i][j]]);
cout << "(" << i << "," << j << ") ";
}
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int> > ds;
ds.clear();
ds.push_back({1, 1});
d[1][1] = 1;
for (int i = 0; i < ds.size(); i++) {
for (int j = 0; j < 4; j++) {
int ii = ds[i].first + hi[j];
int jj = ds[i].second + hj[j];
if (ii > 0 && ii <= n && jj > 0 && jj <= m && d[ii][jj] == 0) {
d[ii][jj] = d[ds[i].first][ds[i].second] + 1;
ds.push_back({ii, jj});
tr[ii][jj] = j;
}
}
}
int ans = 0;
for (int i = 0; i < k; i++) ans += d[ds[i].first][ds[i].second];
cout << ans << '\n';
while (k--) {
trace(ds[k].first, ds[k].second);
cout << '\n';
}
}
|
### Prompt
Construct a cpp code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int hi[] = {0, 0, 1, -1};
const int hj[] = {1, -1, 0, 0};
const int N = 55;
int d[N][N], tr[N][N];
void trace(int i, int j) {
if (i != 1 || j != 1) trace(i - hi[tr[i][j]], j - hj[tr[i][j]]);
cout << "(" << i << "," << j << ") ";
}
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int> > ds;
ds.clear();
ds.push_back({1, 1});
d[1][1] = 1;
for (int i = 0; i < ds.size(); i++) {
for (int j = 0; j < 4; j++) {
int ii = ds[i].first + hi[j];
int jj = ds[i].second + hj[j];
if (ii > 0 && ii <= n && jj > 0 && jj <= m && d[ii][jj] == 0) {
d[ii][jj] = d[ds[i].first][ds[i].second] + 1;
ds.push_back({ii, jj});
tr[ii][jj] = j;
}
}
}
int ans = 0;
for (int i = 0; i < k; i++) ans += d[ds[i].first][ds[i].second];
cout << ans << '\n';
while (k--) {
trace(ds[k].first, ds[k].second);
cout << '\n';
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<string> ans;
queue<int> bfsqx;
queue<int> bfsqy;
queue<int> l;
bool xy[100][100];
int cnt = 0, n, m, k, dp = 0;
void make(int x, int y) {
string str;
char xx = (x % 10) + '0';
char xxx = (x / 10) + '0';
for (int i = 1; i <= x; i++) {
char t = (i % 10) + '0';
char t10 = (i / 10) + '0';
str += " (";
if (t10 != '0') str += t10;
str += t;
str += ",1)";
}
for (int i = 2; i <= y; i++) {
char t = (i % 10) + '0';
char t10 = (i / 10) + '0';
str += " (";
if (xxx != '0') str += xxx;
str += xx;
str += ",";
if (t10 != '0') str += t10;
str += t;
str += ")";
}
ans.push_back(str);
}
void pt(int level, int x, int y) {
if (dp < k && !xy[x][y]) {
cnt += level;
make(x, y);
if (x < n) {
bfsqx.push(x + 1);
bfsqy.push(y);
l.push(level + 1);
}
if (y < m) {
bfsqx.push(x);
bfsqy.push(y + 1);
l.push(level + 1);
}
xy[x][y] = true;
dp++;
}
}
void bfs() {
bfsqx.push(1);
bfsqy.push(1);
l.push(1);
ans.push_back("");
while (!bfsqx.empty()) {
pt(l.front(), bfsqx.front(), bfsqy.front());
l.pop();
bfsqx.pop();
bfsqy.pop();
}
}
int main() {
cin >> n >> m >> k;
bfs();
cout << cnt << endl;
for (int i = k; i > 0; i--) {
cout << ans[i] << endl;
}
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<string> ans;
queue<int> bfsqx;
queue<int> bfsqy;
queue<int> l;
bool xy[100][100];
int cnt = 0, n, m, k, dp = 0;
void make(int x, int y) {
string str;
char xx = (x % 10) + '0';
char xxx = (x / 10) + '0';
for (int i = 1; i <= x; i++) {
char t = (i % 10) + '0';
char t10 = (i / 10) + '0';
str += " (";
if (t10 != '0') str += t10;
str += t;
str += ",1)";
}
for (int i = 2; i <= y; i++) {
char t = (i % 10) + '0';
char t10 = (i / 10) + '0';
str += " (";
if (xxx != '0') str += xxx;
str += xx;
str += ",";
if (t10 != '0') str += t10;
str += t;
str += ")";
}
ans.push_back(str);
}
void pt(int level, int x, int y) {
if (dp < k && !xy[x][y]) {
cnt += level;
make(x, y);
if (x < n) {
bfsqx.push(x + 1);
bfsqy.push(y);
l.push(level + 1);
}
if (y < m) {
bfsqx.push(x);
bfsqy.push(y + 1);
l.push(level + 1);
}
xy[x][y] = true;
dp++;
}
}
void bfs() {
bfsqx.push(1);
bfsqy.push(1);
l.push(1);
ans.push_back("");
while (!bfsqx.empty()) {
pt(l.front(), bfsqx.front(), bfsqy.front());
l.pop();
bfsqx.pop();
bfsqy.pop();
}
}
int main() {
cin >> n >> m >> k;
bfs();
cout << cnt << endl;
for (int i = k; i > 0; i--) {
cout << ans[i] << endl;
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
int v[55][55];
int main() {
int a, b, c;
cin >> a >> b >> c;
int c2 = c;
queue<pair<int, int> > q;
stack<pair<int, int> > s;
q.push(pair<int, int>(1, 1));
long long p = 0;
while (!q.empty()) {
pair<int, int> a2 = q.front();
q.pop();
if (a2.first > a || a2.second > b) continue;
if (v[a2.first][a2.second]) continue;
v[a2.first][a2.second] = 1;
c2--;
s.push(a2);
p += a2.first + a2.second - 1;
if (c2 <= 0) break;
q.push(pair<int, int>(a2.first + 1, a2.second));
q.push(pair<int, int>(a2.first, a2.second + 1));
}
cout << p << endl;
while (!s.empty()) {
pair<int, int> a2 = s.top();
s.pop();
for (int x = 1; x <= a2.first; x++) cout << "(" << x << ",1) ";
for (int y = 2; y <= a2.second; y++)
cout << "(" << a2.first << "," << y << ") ";
cout << endl;
}
}
|
### Prompt
Please provide a Cpp coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int v[55][55];
int main() {
int a, b, c;
cin >> a >> b >> c;
int c2 = c;
queue<pair<int, int> > q;
stack<pair<int, int> > s;
q.push(pair<int, int>(1, 1));
long long p = 0;
while (!q.empty()) {
pair<int, int> a2 = q.front();
q.pop();
if (a2.first > a || a2.second > b) continue;
if (v[a2.first][a2.second]) continue;
v[a2.first][a2.second] = 1;
c2--;
s.push(a2);
p += a2.first + a2.second - 1;
if (c2 <= 0) break;
q.push(pair<int, int>(a2.first + 1, a2.second));
q.push(pair<int, int>(a2.first, a2.second + 1));
}
cout << p << endl;
while (!s.empty()) {
pair<int, int> a2 = s.top();
s.pop();
for (int x = 1; x <= a2.first; x++) cout << "(" << x << ",1) ";
for (int y = 2; y <= a2.second; y++)
cout << "(" << a2.first << "," << y << ") ";
cout << endl;
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m;
queue<int> q;
queue<pair<int, int> > pos;
int dirx[2] = {1, 0};
int diry[2] = {0, 1};
bool valid(int a, int b) { return a > -1 && a < n && b > -1 && b < m; }
int kk;
int g[N][N];
vector<pair<int, int> > path[N * N];
vector<pair<int, int> > v;
bool vis[N][N];
int t;
void dfs(int aa, int bb) {
path[g[aa][bb]] = v;
t += v.size();
vis[aa][bb] = 1;
for (int k = 0; k < 2; k++) {
int xx = aa + dirx[k];
int yy = bb + diry[k];
if (valid(xx, yy) && g[xx][yy] && !vis[xx][yy]) {
v.push_back(make_pair(xx, yy));
dfs(xx, yy);
v.pop_back();
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &kk);
for (int i = 2; i <= kk; i++) {
q.push(i);
}
g[0][0] = 1;
pos.push(make_pair(0, 0));
while (!pos.empty() && !q.empty()) {
int xx = pos.front().first;
int yy = pos.front().second;
pos.pop();
int p = q.front();
for (int k = 0; k < 2; k++) {
int aa = xx + dirx[k];
int bb = yy + diry[k];
if (valid(aa, bb) && !g[aa][bb]) {
g[aa][bb] = p;
q.pop();
pos.push(make_pair(aa, bb));
if (q.empty()) {
break;
}
p = q.front();
}
}
}
v.push_back(make_pair(0, 0));
dfs(0, 0);
printf("%d\n", t);
for (int i = kk; i > 0; i--) {
for (int j = 0; j < path[i].size(); j++) {
if (j) {
printf(" ");
}
printf("(%d,%d)", path[i][j].first + 1, path[i][j].second + 1);
}
printf("\n");
}
return 0;
}
|
### Prompt
Create a solution in CPP for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m;
queue<int> q;
queue<pair<int, int> > pos;
int dirx[2] = {1, 0};
int diry[2] = {0, 1};
bool valid(int a, int b) { return a > -1 && a < n && b > -1 && b < m; }
int kk;
int g[N][N];
vector<pair<int, int> > path[N * N];
vector<pair<int, int> > v;
bool vis[N][N];
int t;
void dfs(int aa, int bb) {
path[g[aa][bb]] = v;
t += v.size();
vis[aa][bb] = 1;
for (int k = 0; k < 2; k++) {
int xx = aa + dirx[k];
int yy = bb + diry[k];
if (valid(xx, yy) && g[xx][yy] && !vis[xx][yy]) {
v.push_back(make_pair(xx, yy));
dfs(xx, yy);
v.pop_back();
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &kk);
for (int i = 2; i <= kk; i++) {
q.push(i);
}
g[0][0] = 1;
pos.push(make_pair(0, 0));
while (!pos.empty() && !q.empty()) {
int xx = pos.front().first;
int yy = pos.front().second;
pos.pop();
int p = q.front();
for (int k = 0; k < 2; k++) {
int aa = xx + dirx[k];
int bb = yy + diry[k];
if (valid(aa, bb) && !g[aa][bb]) {
g[aa][bb] = p;
q.pop();
pos.push(make_pair(aa, bb));
if (q.empty()) {
break;
}
p = q.front();
}
}
}
v.push_back(make_pair(0, 0));
dfs(0, 0);
printf("%d\n", t);
for (int i = kk; i > 0; i--) {
for (int j = 0; j < path[i].size(); j++) {
if (j) {
printf(" ");
}
printf("(%d,%d)", path[i][j].first + 1, path[i][j].second + 1);
}
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, ans = 0;
int mat[55][55];
vector<pair<int, int> > v;
void go() {
queue<pair<int, pair<int, int> > > q;
q.push({1, {1, 1}});
int baki = k;
while (baki) {
pair<int, pair<int, int> > p = q.front();
q.pop();
int x = p.second.first, y = p.second.second, w = p.first;
if (mat[x][y]) continue;
ans += p.first;
baki--;
mat[x][y] = 1;
if (x + 1 <= n) q.push({w + 1, {x + 1, y}});
if (y + 1 <= m) q.push({w + 1, {x, y + 1}});
}
}
int main() {
int i, j;
cin >> n >> m >> k;
go();
cout << ans << endl;
v.push_back({1, 1});
for (i = 1; i <= n; i++) {
if (i == 1)
j = 2;
else
j = 1;
for (; j <= m; j++) {
if (mat[i][j] == 0) break;
v.push_back({i, j});
}
while (v.size() > i) {
for (auto x : v) {
printf("(%d,%d) ", x.first, x.second);
}
printf("\n");
v.pop_back();
}
}
while (v.size()) {
for (auto x : v) {
printf("(%d,%d) ", x.first, x.second);
}
printf("\n");
v.pop_back();
}
return 0;
}
|
### Prompt
Your task is to create a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, ans = 0;
int mat[55][55];
vector<pair<int, int> > v;
void go() {
queue<pair<int, pair<int, int> > > q;
q.push({1, {1, 1}});
int baki = k;
while (baki) {
pair<int, pair<int, int> > p = q.front();
q.pop();
int x = p.second.first, y = p.second.second, w = p.first;
if (mat[x][y]) continue;
ans += p.first;
baki--;
mat[x][y] = 1;
if (x + 1 <= n) q.push({w + 1, {x + 1, y}});
if (y + 1 <= m) q.push({w + 1, {x, y + 1}});
}
}
int main() {
int i, j;
cin >> n >> m >> k;
go();
cout << ans << endl;
v.push_back({1, 1});
for (i = 1; i <= n; i++) {
if (i == 1)
j = 2;
else
j = 1;
for (; j <= m; j++) {
if (mat[i][j] == 0) break;
v.push_back({i, j});
}
while (v.size() > i) {
for (auto x : v) {
printf("(%d,%d) ", x.first, x.second);
}
printf("\n");
v.pop_back();
}
}
while (v.size()) {
for (auto x : v) {
printf("(%d,%d) ", x.first, x.second);
}
printf("\n");
v.pop_back();
}
return 0;
}
```
|
#include <bits/stdc++.h>
int n, m;
int map[55][55], qx[11111], qy[11111], tot, next[11111];
int main() {
int dfs(int x);
int k, i, j, x, y, d, sum, t;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) map[i][j] = 0;
tot = 1;
qx[0] = 1;
qy[0] = 1;
map[1][1] = 1;
next[0] = -1;
d = 0;
while (tot < k) {
x = qx[d];
y = qy[d];
d++;
if (!map[x][y + 1] && y + 1 <= m) {
next[tot] = d - 1;
qx[tot] = x;
qy[tot++] = y + 1;
map[x][y + 1] = 1;
}
if (!map[x + 1][y] && x + 1 <= n) {
next[tot] = d - 1;
qx[tot] = x + 1;
qy[tot++] = y;
map[x + 1][y] = 1;
}
}
sum = 0;
for (i = k - 1; i >= 0; i--) {
sum++;
t = i;
while (next[t] >= 0) {
sum++;
t = next[t];
}
}
printf("%d\n", sum);
for (i = k - 1; i >= 0; i--) {
dfs(i);
printf("\n");
}
}
int dfs(int x) {
if (next[x] == -1) {
printf("(%d,%d) ", qx[x], qy[x]);
return 1;
}
dfs(next[x]);
printf("(%d,%d) ", qx[x], qy[x]);
return 1;
}
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
int n, m;
int map[55][55], qx[11111], qy[11111], tot, next[11111];
int main() {
int dfs(int x);
int k, i, j, x, y, d, sum, t;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) map[i][j] = 0;
tot = 1;
qx[0] = 1;
qy[0] = 1;
map[1][1] = 1;
next[0] = -1;
d = 0;
while (tot < k) {
x = qx[d];
y = qy[d];
d++;
if (!map[x][y + 1] && y + 1 <= m) {
next[tot] = d - 1;
qx[tot] = x;
qy[tot++] = y + 1;
map[x][y + 1] = 1;
}
if (!map[x + 1][y] && x + 1 <= n) {
next[tot] = d - 1;
qx[tot] = x + 1;
qy[tot++] = y;
map[x + 1][y] = 1;
}
}
sum = 0;
for (i = k - 1; i >= 0; i--) {
sum++;
t = i;
while (next[t] >= 0) {
sum++;
t = next[t];
}
}
printf("%d\n", sum);
for (i = k - 1; i >= 0; i--) {
dfs(i);
printf("\n");
}
}
int dfs(int x) {
if (next[x] == -1) {
printf("(%d,%d) ", qx[x], qy[x]);
return 1;
}
dfs(next[x]);
printf("(%d,%d) ", qx[x], qy[x]);
return 1;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
struct node {
int x, y;
} grid[maxn * maxn];
int n, m, k, num;
bool cmp(node a, node b) { return a.x + a.y < b.x + b.y; }
int main() {
num = 0;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) grid[num].x = i, grid[num++].y = j;
sort(grid, grid + n * m, cmp);
int ans = 0;
for (int i = 0; i < k; i++) ans += grid[i].x + grid[i].y - 1;
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
for (int j = 1; j <= grid[i].x; j++) printf("(%d,%d) ", j, 1);
for (int j = 2; j <= grid[i].y; j++) printf("(%d,%d) ", grid[i].x, j);
cout << endl;
}
return 0;
}
|
### Prompt
Please create a solution in Cpp to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
struct node {
int x, y;
} grid[maxn * maxn];
int n, m, k, num;
bool cmp(node a, node b) { return a.x + a.y < b.x + b.y; }
int main() {
num = 0;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) grid[num].x = i, grid[num++].y = j;
sort(grid, grid + n * m, cmp);
int ans = 0;
for (int i = 0; i < k; i++) ans += grid[i].x + grid[i].y - 1;
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
for (int j = 1; j <= grid[i].x; j++) printf("(%d,%d) ", j, 1);
for (int j = 2; j <= grid[i].y; j++) printf("(%d,%d) ", grid[i].x, j);
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool fuck[55][55];
int qx[3005], qy[3005];
int tot = 0;
int main() {
scanf("%d%d%d", &n, &m, &k);
int ans = 0;
for (int i = 2; i <= n + m; i++) {
if (!k) break;
for (int j = 1; j <= n; j++)
if (i - j > 0 && i - j <= m) {
if (!k) break;
k--;
fuck[j][i - j] = 1;
ans += i - 1;
++tot;
qx[tot] = j;
qy[tot] = i - j;
}
}
printf("%d\n", ans);
for (int i = tot; i >= 1; i--) {
for (int j = 1; j <= qx[i]; j++) printf("(%d,1) ", j);
for (int j = 2; j <= qy[i]; j++) printf("(%d,%d) ", qx[i], j);
printf("\n");
}
return 0;
}
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool fuck[55][55];
int qx[3005], qy[3005];
int tot = 0;
int main() {
scanf("%d%d%d", &n, &m, &k);
int ans = 0;
for (int i = 2; i <= n + m; i++) {
if (!k) break;
for (int j = 1; j <= n; j++)
if (i - j > 0 && i - j <= m) {
if (!k) break;
k--;
fuck[j][i - j] = 1;
ans += i - 1;
++tot;
qx[tot] = j;
qy[tot] = i - j;
}
}
printf("%d\n", ans);
for (int i = tot; i >= 1; i--) {
for (int j = 1; j <= qx[i]; j++) printf("(%d,1) ", j);
for (int j = 2; j <= qy[i]; j++) printf("(%d,%d) ", qx[i], j);
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
const double pi = 4.0 * atan(1.0);
const int maxn = 3e5 + 8;
const long long mod = 1e9 + 7;
const unsigned long long base = 1e7 + 7;
using namespace std;
pair<int, int> ans[maxn];
int l[maxn];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
l[i + j - 1]++;
}
}
int cnt = 0;
int sum = 0;
for (int i = 1; i <= n + m - 1 && k; i++) {
if (k > l[i]) {
k -= l[i];
sum += l[i] * i;
for (int j = 1; j <= n; j++) {
if (i + 1 - j < 1 || i + 1 - j > m) continue;
ans[++cnt] = {j, i + 1 - j};
}
} else {
sum += k * i;
for (int j = 1; j <= n && k; j++) {
if (i + 1 - j < 1 || i + 1 - j > m) continue;
ans[++cnt] = {j, i + 1 - j};
k--;
}
k = 0;
}
}
printf("%d\n", sum);
for (int i = cnt; i >= 1; i--) {
int x = 1, y = 1;
printf("(1,1)");
while (x + 1 <= ans[i].first) {
x++;
printf(" (%d,%d)", x, y);
}
y++;
while (y <= ans[i].second) {
printf(" (%d,%d)", x, y);
y++;
}
printf("\n");
}
}
|
### Prompt
Generate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
const double pi = 4.0 * atan(1.0);
const int maxn = 3e5 + 8;
const long long mod = 1e9 + 7;
const unsigned long long base = 1e7 + 7;
using namespace std;
pair<int, int> ans[maxn];
int l[maxn];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
l[i + j - 1]++;
}
}
int cnt = 0;
int sum = 0;
for (int i = 1; i <= n + m - 1 && k; i++) {
if (k > l[i]) {
k -= l[i];
sum += l[i] * i;
for (int j = 1; j <= n; j++) {
if (i + 1 - j < 1 || i + 1 - j > m) continue;
ans[++cnt] = {j, i + 1 - j};
}
} else {
sum += k * i;
for (int j = 1; j <= n && k; j++) {
if (i + 1 - j < 1 || i + 1 - j > m) continue;
ans[++cnt] = {j, i + 1 - j};
k--;
}
k = 0;
}
}
printf("%d\n", sum);
for (int i = cnt; i >= 1; i--) {
int x = 1, y = 1;
printf("(1,1)");
while (x + 1 <= ans[i].first) {
x++;
printf(" (%d,%d)", x, y);
}
y++;
while (y <= ans[i].second) {
printf(" (%d,%d)", x, y);
y++;
}
printf("\n");
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int i, j;
} a[3000];
int n, m, k, ans, cnt;
bool cmp(data a, data b) { return a.i + a.j < b.i + b.j; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[++cnt] = (data){i, j};
sort(a + 1, a + 1 + cnt, cmp);
for (int i = k; i; i--) ans += a[i].i + a[i].j - 1;
printf("%d\n", ans);
for (int i = k; i; i--) {
for (int x = 1, y = 1; x <= a[i].i && y <= a[i].j;) {
if (x == a[i].i && y == a[i].j) {
printf("(%d,%d)\n", x, y);
break;
}
printf("(%d,%d) ", x, y);
if (x < a[i].i)
x++;
else
y++;
}
}
}
|
### Prompt
Your task is to create a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct data {
int i, j;
} a[3000];
int n, m, k, ans, cnt;
bool cmp(data a, data b) { return a.i + a.j < b.i + b.j; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[++cnt] = (data){i, j};
sort(a + 1, a + 1 + cnt, cmp);
for (int i = k; i; i--) ans += a[i].i + a[i].j - 1;
printf("%d\n", ans);
for (int i = k; i; i--) {
for (int x = 1, y = 1; x <= a[i].i && y <= a[i].j;) {
if (x == a[i].i && y == a[i].j) {
printf("(%d,%d)\n", x, y);
break;
}
printf("(%d,%d) ", x, y);
if (x < a[i].i)
x++;
else
y++;
}
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 60 * 60;
pair<int, int> h[MAXN];
bool byDis(pair<int, int> x, pair<int, int> y) {
return (x.first + x.second < y.first + y.second);
}
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
int sz = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) h[sz++] = pair<int, int>(i + 1, j + 1);
sort(h, h + sz, byDis);
long long sum = 0;
for (int i = 0; i < k; i++) sum += h[i].first + h[i].second - 1;
cout << sum << endl;
for (int i = k - 1; i >= 0; i--) {
for (int x = 1; x <= h[i].first; x++) cout << "(" << x << ", 1) ";
for (int y = 2; y <= h[i].second; y++)
cout << "(" << h[i].first << ", " << y << ") ";
cout << "\n";
}
}
|
### Prompt
Construct a CPP code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 60 * 60;
pair<int, int> h[MAXN];
bool byDis(pair<int, int> x, pair<int, int> y) {
return (x.first + x.second < y.first + y.second);
}
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
int sz = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) h[sz++] = pair<int, int>(i + 1, j + 1);
sort(h, h + sz, byDis);
long long sum = 0;
for (int i = 0; i < k; i++) sum += h[i].first + h[i].second - 1;
cout << sum << endl;
for (int i = k - 1; i >= 0; i--) {
for (int x = 1; x <= h[i].first; x++) cout << "(" << x << ", 1) ";
for (int y = 2; y <= h[i].second; y++)
cout << "(" << h[i].first << ", " << y << ") ";
cout << "\n";
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
const double EPS = 1e-8;
const double PI = acos(-1.0);
int popcount(int n) { return __builtin_popcount(n); }
int popcount(long long n) { return __builtin_popcountll(n); }
template <class T>
int SIZE(T a) {
return a.size();
}
template <class T>
string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
template <class T>
T StringToInt(string str) {
T res = 0;
for (int i = 0; i < SIZE(str); i++) res = (res * 10 + str[i] - '0');
return res;
}
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
void PrintSeq(T &a, int sz) {
for (int i = 0; i < sz; i++) {
cout << a[i];
if (sz == i + 1)
cout << endl;
else
cout << ' ';
}
}
long long getTen(int a) { return (a <= 0) ? 1 : (getTen(a - 1) * 10); }
bool EQ(double a, double b) { return abs(a - b) < EPS; }
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
vector<string> split(string str, char del) {
vector<string> res;
for (int i = 0, s = 0; i < SIZE(str); i++) {
if (str[i] == del) {
if (i - s != 0) res.push_back(str.substr(s, i - s));
s = i + 1;
} else if (i == SIZE(str) - 1) {
res.push_back(str.substr(s));
}
}
return res;
}
int H, W, K;
int main() {
cin >> H >> W >> K;
vector<pair<int, int> > poss;
int sum = 0;
for (int i = 0;; i++) {
for (int j = 0; j <= i; j++) {
int x = j;
int y = i - j;
if (x >= 0 && y >= 0 && x < W && y < H) {
poss.push_back(pair<int, int>(y, x));
sum += (y + x + 1);
}
if ((int)poss.size() == K) break;
}
if ((int)poss.size() == K) break;
}
cout << sum << endl;
for (int i = (int)poss.size() - 1; i >= 0; i--) {
int y = poss[i].first;
int x = poss[i].second;
int initx = 0;
int inity = 0;
cout << "(";
cout << inity + 1 << ",";
cout << initx + 1;
cout << ")";
cout << " ";
while (initx + 1 <= x) {
initx++;
cout << "(";
cout << inity + 1 << ",";
cout << initx + 1;
cout << ")";
cout << " ";
}
while (inity + 1 <= y) {
inity++;
cout << "(";
cout << inity + 1 << ",";
cout << initx + 1;
cout << ")";
cout << " ";
}
cout << endl;
}
return 0;
}
|
### Prompt
Create a solution in Cpp for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
const double EPS = 1e-8;
const double PI = acos(-1.0);
int popcount(int n) { return __builtin_popcount(n); }
int popcount(long long n) { return __builtin_popcountll(n); }
template <class T>
int SIZE(T a) {
return a.size();
}
template <class T>
string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
template <class T>
T StringToInt(string str) {
T res = 0;
for (int i = 0; i < SIZE(str); i++) res = (res * 10 + str[i] - '0');
return res;
}
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
void PrintSeq(T &a, int sz) {
for (int i = 0; i < sz; i++) {
cout << a[i];
if (sz == i + 1)
cout << endl;
else
cout << ' ';
}
}
long long getTen(int a) { return (a <= 0) ? 1 : (getTen(a - 1) * 10); }
bool EQ(double a, double b) { return abs(a - b) < EPS; }
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
vector<string> split(string str, char del) {
vector<string> res;
for (int i = 0, s = 0; i < SIZE(str); i++) {
if (str[i] == del) {
if (i - s != 0) res.push_back(str.substr(s, i - s));
s = i + 1;
} else if (i == SIZE(str) - 1) {
res.push_back(str.substr(s));
}
}
return res;
}
int H, W, K;
int main() {
cin >> H >> W >> K;
vector<pair<int, int> > poss;
int sum = 0;
for (int i = 0;; i++) {
for (int j = 0; j <= i; j++) {
int x = j;
int y = i - j;
if (x >= 0 && y >= 0 && x < W && y < H) {
poss.push_back(pair<int, int>(y, x));
sum += (y + x + 1);
}
if ((int)poss.size() == K) break;
}
if ((int)poss.size() == K) break;
}
cout << sum << endl;
for (int i = (int)poss.size() - 1; i >= 0; i--) {
int y = poss[i].first;
int x = poss[i].second;
int initx = 0;
int inity = 0;
cout << "(";
cout << inity + 1 << ",";
cout << initx + 1;
cout << ")";
cout << " ";
while (initx + 1 <= x) {
initx++;
cout << "(";
cout << inity + 1 << ",";
cout << initx + 1;
cout << ")";
cout << " ";
}
while (inity + 1 <= y) {
inity++;
cout << "(";
cout << inity + 1 << ",";
cout << initx + 1;
cout << ")";
cout << " ";
}
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int mat[50][50];
void print_path(int n, int m) {
for (int i = 0; i < m - 1; ++i) {
cout << "(1," << (i + 1) << ") ";
}
for (int i = 0; i < n; ++i) {
cout << "(" << (i + 1) << "," << m << ") ";
}
cout << endl;
}
int main() {
int n, m, k;
while (cin >> n >> m >> k) {
vector<pair<int, int> > mvec;
int l = 1;
while (true) {
if (l & 1) {
int x = (l >= n) ? (n) : (l), y = (l >= n) ? (l - n + 1) : 1;
while (k > 0) {
if (x < 1 || y > m) break;
mvec.push_back(pair<int, int>(x--, y++));
k--;
}
} else {
int x = (l >= m) ? (l - m + 1) : 1, y = (l >= m) ? m : l;
while (k > 0) {
if (y < 1 || x > n) break;
mvec.push_back(pair<int, int>(x++, y--));
k--;
}
}
l++;
if (k <= 0) break;
}
reverse(mvec.begin(), mvec.end());
int res = 0;
for (int i = 0; i < (int)mvec.size(); ++i)
res += (mvec[i].first + mvec[i].second - 1);
cout << res << endl;
for (int i = 0; i < (int)mvec.size(); ++i) {
print_path(mvec[i].first, mvec[i].second);
}
}
}
|
### Prompt
Please formulate a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int mat[50][50];
void print_path(int n, int m) {
for (int i = 0; i < m - 1; ++i) {
cout << "(1," << (i + 1) << ") ";
}
for (int i = 0; i < n; ++i) {
cout << "(" << (i + 1) << "," << m << ") ";
}
cout << endl;
}
int main() {
int n, m, k;
while (cin >> n >> m >> k) {
vector<pair<int, int> > mvec;
int l = 1;
while (true) {
if (l & 1) {
int x = (l >= n) ? (n) : (l), y = (l >= n) ? (l - n + 1) : 1;
while (k > 0) {
if (x < 1 || y > m) break;
mvec.push_back(pair<int, int>(x--, y++));
k--;
}
} else {
int x = (l >= m) ? (l - m + 1) : 1, y = (l >= m) ? m : l;
while (k > 0) {
if (y < 1 || x > n) break;
mvec.push_back(pair<int, int>(x++, y--));
k--;
}
}
l++;
if (k <= 0) break;
}
reverse(mvec.begin(), mvec.end());
int res = 0;
for (int i = 0; i < (int)mvec.size(); ++i)
res += (mvec[i].first + mvec[i].second - 1);
cout << res << endl;
for (int i = 0; i < (int)mvec.size(); ++i) {
print_path(mvec[i].first, mvec[i].second);
}
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int M[60][60];
int dx[] = {0, 1};
int dy[] = {1, 0};
std::vector<pair<int, int> > path;
int sum = 0;
void dfs(int ia, int ja) {
M[ia][ja] = 1;
path.push_back(make_pair(ia, ja));
for (int i = 0; i < 2; i++) {
if (ia + dx[i] > 0 && ia + dx[i] <= n && ja + dy[i] > 0 &&
ja + dy[i] <= m && M[ia + dx[i]][ja + dy[i]] == 0) {
dfs(ia + dx[i], ja + dy[i]);
}
}
for (int i = 0; i < path.size(); i++) {
if (i != 0) cout << " ";
cout << "(" << path[i].first << "," << path[i].second << ")";
}
cout << endl;
path.pop_back();
}
int main() {
cin >> n >> m >> k;
memset(M, -1, sizeof M);
queue<pair<int, int> > fila;
int c = 1;
M[1][1] = 0;
fila.push(make_pair(1, 1));
while (!fila.empty() && c < k) {
pair<int, int> p = fila.front();
fila.pop();
for (int i = 0; i < 2 && c < k; i++) {
if (p.first + dx[i] > 0 && p.first + dx[i] <= n && p.second + dy[i] > 0 &&
p.second + dy[i] <= m && M[p.first + dx[i]][p.second + dy[i]] == -1) {
fila.push(make_pair(p.first + dx[i], p.second + dy[i]));
M[p.first + dx[i]][p.second + dy[i]] = 0;
c++;
sum += abs(p.first + dx[i] - 1) + abs(p.second + dy[i] - 1) + 1;
}
}
}
cout << sum + 1 << endl;
dfs(1, 1);
return 0;
}
|
### Prompt
Please provide a Cpp coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int M[60][60];
int dx[] = {0, 1};
int dy[] = {1, 0};
std::vector<pair<int, int> > path;
int sum = 0;
void dfs(int ia, int ja) {
M[ia][ja] = 1;
path.push_back(make_pair(ia, ja));
for (int i = 0; i < 2; i++) {
if (ia + dx[i] > 0 && ia + dx[i] <= n && ja + dy[i] > 0 &&
ja + dy[i] <= m && M[ia + dx[i]][ja + dy[i]] == 0) {
dfs(ia + dx[i], ja + dy[i]);
}
}
for (int i = 0; i < path.size(); i++) {
if (i != 0) cout << " ";
cout << "(" << path[i].first << "," << path[i].second << ")";
}
cout << endl;
path.pop_back();
}
int main() {
cin >> n >> m >> k;
memset(M, -1, sizeof M);
queue<pair<int, int> > fila;
int c = 1;
M[1][1] = 0;
fila.push(make_pair(1, 1));
while (!fila.empty() && c < k) {
pair<int, int> p = fila.front();
fila.pop();
for (int i = 0; i < 2 && c < k; i++) {
if (p.first + dx[i] > 0 && p.first + dx[i] <= n && p.second + dy[i] > 0 &&
p.second + dy[i] <= m && M[p.first + dx[i]][p.second + dy[i]] == -1) {
fila.push(make_pair(p.first + dx[i], p.second + dy[i]));
M[p.first + dx[i]][p.second + dy[i]] = 0;
c++;
sum += abs(p.first + dx[i] - 1) + abs(p.second + dy[i] - 1) + 1;
}
}
}
cout << sum + 1 << endl;
dfs(1, 1);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
using namespace placeholders;
template <class T>
void mini(T &l, T r) {
l = min(l, r);
}
template <class T>
void maxi(T &l, T r) {
l = max(l, r);
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> v) {
os << "[";
for (auto vv : v) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> p) {
return os << "(" << p.first << "," << p.second << ")";
}
const int N = 60;
int n, m, k;
int a[N][N];
vector<pair<int, int> > go(pair<int, int> p) {
int x = p.first, y = p.second;
vector<pair<int, int> > ret;
for (int i = 1; i <= x; ++i) {
ret.push_back(make_pair(i, 1));
}
for (int i = 2; i <= y; ++i) {
ret.push_back(make_pair(x, i));
}
return ret;
}
void print(vector<pair<int, int> > p) {
for (int i = 0; i < p.size(); ++i) {
printf("(%d,%d)%c", p[i].first, p[i].second, " \n"[i == (int)p.size() - 1]);
}
}
void run() {
scanf("%d%d%d", &n, &m, &k);
vector<pair<int, pair<int, int> > > v;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
a[i][j] = i + j - 1 - 1;
v.push_back(make_pair(a[i][j], make_pair(i, j)));
}
}
sort(v.begin(), v.end());
v.erase(v.begin() + k, v.end());
reverse(v.begin(), v.end());
;
int ans = 0;
vector<vector<pair<int, int> > > path(k);
for (int i = 0; i < k; ++i) {
path[i] = go(v[i].second);
ans += path[i].size();
}
printf("%d\n", ans);
for (auto pth : path) {
print(pth);
}
}
int main() {
run();
return 0;
}
|
### Prompt
Construct a CPP code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using namespace placeholders;
template <class T>
void mini(T &l, T r) {
l = min(l, r);
}
template <class T>
void maxi(T &l, T r) {
l = max(l, r);
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> v) {
os << "[";
for (auto vv : v) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> p) {
return os << "(" << p.first << "," << p.second << ")";
}
const int N = 60;
int n, m, k;
int a[N][N];
vector<pair<int, int> > go(pair<int, int> p) {
int x = p.first, y = p.second;
vector<pair<int, int> > ret;
for (int i = 1; i <= x; ++i) {
ret.push_back(make_pair(i, 1));
}
for (int i = 2; i <= y; ++i) {
ret.push_back(make_pair(x, i));
}
return ret;
}
void print(vector<pair<int, int> > p) {
for (int i = 0; i < p.size(); ++i) {
printf("(%d,%d)%c", p[i].first, p[i].second, " \n"[i == (int)p.size() - 1]);
}
}
void run() {
scanf("%d%d%d", &n, &m, &k);
vector<pair<int, pair<int, int> > > v;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
a[i][j] = i + j - 1 - 1;
v.push_back(make_pair(a[i][j], make_pair(i, j)));
}
}
sort(v.begin(), v.end());
v.erase(v.begin() + k, v.end());
reverse(v.begin(), v.end());
;
int ans = 0;
vector<vector<pair<int, int> > > path(k);
for (int i = 0; i < k; ++i) {
path[i] = go(v[i].second);
ans += path[i].size();
}
printf("%d\n", ans);
for (auto pth : path) {
print(pth);
}
}
int main() {
run();
return 0;
}
```
|
#include <bits/stdc++.h>
int policka[50 * 50 + 10][2];
int main() {
int m, n, k, p = 0;
scanf("%d%d%d", &n, &m, &k);
int x = 1, y = 1, l = 1;
for (int i = 0; i < k; i++) {
policka[i][0] = y;
policka[i][1] = x;
p += l;
x--;
y++;
if (x < 1 || y > n) {
l++;
x = ((l) < (m) ? (l) : (m));
y = l + 1 - x;
}
}
printf("%d\n", p);
for (int i = k - 1; i >= 0; i--) {
for (int y = 1; y <= policka[i][0]; y++) {
printf("(%d,1) ", y);
}
for (int x = 2; x <= policka[i][1]; x++) {
printf("(%d,%d) ", policka[i][0], x);
}
printf("\n");
}
}
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
int policka[50 * 50 + 10][2];
int main() {
int m, n, k, p = 0;
scanf("%d%d%d", &n, &m, &k);
int x = 1, y = 1, l = 1;
for (int i = 0; i < k; i++) {
policka[i][0] = y;
policka[i][1] = x;
p += l;
x--;
y++;
if (x < 1 || y > n) {
l++;
x = ((l) < (m) ? (l) : (m));
y = l + 1 - x;
}
}
printf("%d\n", p);
for (int i = k - 1; i >= 0; i--) {
for (int y = 1; y <= policka[i][0]; y++) {
printf("(%d,1) ", y);
}
for (int x = 2; x <= policka[i][1]; x++) {
printf("(%d,%d) ", policka[i][0], x);
}
printf("\n");
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
vector<pii> p, path;
int n, m, k;
int main() {
scanf("%d%d%d", &n, &m, &k);
int tot = 0;
for (int d = 0; (int)p.size() < k; ++d) {
for (int i = 0; i <= d && (int)p.size() < k; ++i)
if (i < n && d - i < m) {
p.push_back({i, d - i});
tot += d + 1;
}
}
printf("%d\n", tot);
while (!p.empty()) {
pii q = p.back();
int x = q.first, y = q.second;
path.clear();
while (true) {
path.push_back({x + 1, y + 1});
if (x + y == 0) break;
if (x > 0)
--x;
else
--y;
}
reverse(path.begin(), path.end());
for (auto &t : path) printf("(%d,%d) ", t.first, t.second);
puts("");
p.pop_back();
}
return 0;
}
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
vector<pii> p, path;
int n, m, k;
int main() {
scanf("%d%d%d", &n, &m, &k);
int tot = 0;
for (int d = 0; (int)p.size() < k; ++d) {
for (int i = 0; i <= d && (int)p.size() < k; ++i)
if (i < n && d - i < m) {
p.push_back({i, d - i});
tot += d + 1;
}
}
printf("%d\n", tot);
while (!p.empty()) {
pii q = p.back();
int x = q.first, y = q.second;
path.clear();
while (true) {
path.push_back({x + 1, y + 1});
if (x + y == 0) break;
if (x > 0)
--x;
else
--y;
}
reverse(path.begin(), path.end());
for (auto &t : path) printf("(%d,%d) ", t.first, t.second);
puts("");
p.pop_back();
}
return 0;
}
```
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MAX = 2e5 + 5;
const long long MAX2 = 11;
const long long MOD = 998244353;
const long long MOD2 = 1000005329;
const long long INF = 2e18;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 2000;
int n, m, k, ans, a, b;
vector<pair<int, int> > v;
inline bool cmp(pair<int, int> a, pair<int, int> b) {
return a.first + a.second < b.first + b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) v.push_back({i, j});
sort(v.begin(), v.end(), cmp);
--k;
for (int i = 0; i <= k; ++i) ans += v[i].first + v[i].second - 1;
cout << ans << '\n';
for (int i = k; i >= 0; --i) {
a = 0, b = 1;
while (a != v[i].first) {
++a;
cout << '(' << a << ',' << b << ") ";
}
while (b != v[i].second) {
++b;
cout << '(' << a << ',' << b << ") ";
}
cout << '\n';
}
return 0;
}
|
### Prompt
Generate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MAX = 2e5 + 5;
const long long MAX2 = 11;
const long long MOD = 998244353;
const long long MOD2 = 1000005329;
const long long INF = 2e18;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 2000;
int n, m, k, ans, a, b;
vector<pair<int, int> > v;
inline bool cmp(pair<int, int> a, pair<int, int> b) {
return a.first + a.second < b.first + b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) v.push_back({i, j});
sort(v.begin(), v.end(), cmp);
--k;
for (int i = 0; i <= k; ++i) ans += v[i].first + v[i].second - 1;
cout << ans << '\n';
for (int i = k; i >= 0; --i) {
a = 0, b = 1;
while (a != v[i].first) {
++a;
cout << '(' << a << ',' << b << ") ";
}
while (b != v[i].second) {
++b;
cout << '(' << a << ',' << b << ") ";
}
cout << '\n';
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
bool fsl(pair<int, int> a, pair<int, int> b) {
return a.first + a.second < b.first + b.second;
}
void print(pair<int, int> p) {
if (p.first == 1 and p.second == 1)
cout << "(1,1) ";
else if (p.first > 1) {
print(make_pair(p.first - 1, p.second));
cout << "(" << p.first << "," << p.second << ") ";
} else if (p.second > 1) {
print(make_pair(p.first, p.second - 1));
cout << "(" << p.first << "," << p.second << ") ";
}
}
int main() {
vector<pair<int, int> > place;
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) place.push_back(make_pair(i, j));
sort(place.begin(), place.end(), fsl);
place.resize(k);
int ans = 0;
for (int i = 0; i < place.size(); ++i)
ans += place[i].first + place[i].second - 1;
cout << fixed << ans << endl;
for (int i = k - 1; i >= 0; --i) {
print(place[i]);
cout << endl;
}
return 0;
}
|
### Prompt
Develop a solution in CPP to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool fsl(pair<int, int> a, pair<int, int> b) {
return a.first + a.second < b.first + b.second;
}
void print(pair<int, int> p) {
if (p.first == 1 and p.second == 1)
cout << "(1,1) ";
else if (p.first > 1) {
print(make_pair(p.first - 1, p.second));
cout << "(" << p.first << "," << p.second << ") ";
} else if (p.second > 1) {
print(make_pair(p.first, p.second - 1));
cout << "(" << p.first << "," << p.second << ") ";
}
}
int main() {
vector<pair<int, int> > place;
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) place.push_back(make_pair(i, j));
sort(place.begin(), place.end(), fsl);
place.resize(k);
int ans = 0;
for (int i = 0; i < place.size(); ++i)
ans += place[i].first + place[i].second - 1;
cout << fixed << ans << endl;
for (int i = k - 1; i >= 0; --i) {
print(place[i]);
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3000;
pair<int, int> a[N];
int n, m, k;
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first + a.second == b.first + b.second)
return a.first < b.first;
else
return a.first + a.second < b.first + b.second;
}
void prepare() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[m * (i - 1) + j] = pair<int, int>(i, j);
sort(a + 1, a + m * n + 1, comp);
}
void solve() {
int ans = 0;
for (int i = 1; i <= k; i++) ans += a[i].first + a[i].second - 1;
printf("%d\n", ans);
for (int i = k; i >= 1; i--) {
for (int j = 1; j <= a[i].first; j++) printf("(%d,1) ", j);
for (int j = 2; j <= a[i].second; j++) printf("(%d,%d) ", a[i].first, j);
printf("\n");
}
}
int main() {
prepare();
solve();
}
|
### Prompt
Construct a cpp code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 3000;
pair<int, int> a[N];
int n, m, k;
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first + a.second == b.first + b.second)
return a.first < b.first;
else
return a.first + a.second < b.first + b.second;
}
void prepare() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[m * (i - 1) + j] = pair<int, int>(i, j);
sort(a + 1, a + m * n + 1, comp);
}
void solve() {
int ans = 0;
for (int i = 1; i <= k; i++) ans += a[i].first + a[i].second - 1;
printf("%d\n", ans);
for (int i = k; i >= 1; i--) {
for (int j = 1; j <= a[i].first; j++) printf("(%d,1) ", j);
for (int j = 2; j <= a[i].second; j++) printf("(%d,%d) ", a[i].first, j);
printf("\n");
}
}
int main() {
prepare();
solve();
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, r, level, sum, d[55][55];
bool vis[55][55];
int main() {
scanf("%d %d %d", &n, &m, &k);
queue<pair<int, int> > q;
q.push({1, 1});
d[1][1] = 1;
vector<pair<int, int> > v;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
v.push_back({d[x][y], x * 100 + y});
if (x + 1 <= n && !vis[x + 1][y]) {
vis[x + 1][y] = true;
d[x + 1][y] = d[x][y] + 1;
q.push({x + 1, y});
}
if (y + 1 <= m && !vis[x][y + 1]) {
vis[x][y + 1] = true;
d[x][y + 1] = d[x][y] + 1;
q.push({x, y + 1});
}
}
int ans = 0;
for (int i = 0; i < k; i++) ans += v[i].first;
printf("%d\n", ans);
for (int i = k - 1; i >= 0; i--) {
int x = v[i].second / 100, y = v[i].second % 100;
printf("(1,1)");
for (int j = 2; j <= x; j++) printf(" (%d,%d)", j, 1);
for (int j = 2; j <= y; j++) printf(" (%d,%d)", x, j);
printf("\n");
}
return 0;
}
|
### Prompt
Generate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, r, level, sum, d[55][55];
bool vis[55][55];
int main() {
scanf("%d %d %d", &n, &m, &k);
queue<pair<int, int> > q;
q.push({1, 1});
d[1][1] = 1;
vector<pair<int, int> > v;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
v.push_back({d[x][y], x * 100 + y});
if (x + 1 <= n && !vis[x + 1][y]) {
vis[x + 1][y] = true;
d[x + 1][y] = d[x][y] + 1;
q.push({x + 1, y});
}
if (y + 1 <= m && !vis[x][y + 1]) {
vis[x][y + 1] = true;
d[x][y + 1] = d[x][y] + 1;
q.push({x, y + 1});
}
}
int ans = 0;
for (int i = 0; i < k; i++) ans += v[i].first;
printf("%d\n", ans);
for (int i = k - 1; i >= 0; i--) {
int x = v[i].second / 100, y = v[i].second % 100;
printf("(1,1)");
for (int j = 2; j <= x; j++) printf(" (%d,%d)", j, 1);
for (int j = 2; j <= y; j++) printf(" (%d,%d)", x, j);
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<vector<pair<int, int> > > v;
int main() {
ios ::sync_with_stdio(0);
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
cin >> n >> m >> k;
int r = 1, c = 1;
while (k--) {
v.push_back(vector<pair<int, int> >());
for (int i = 1; i <= r; i++) v.back().push_back(pair<int, int>(i, 1));
for (int i = 2; i <= c; i++) v.back().push_back(pair<int, int>(r, i));
if (k == 0) break;
do {
if (c == 1)
c = r + 1, r = 1;
else
r++, c--;
} while (r > n || c > m);
}
int ans = 0;
for (int i = 0; i < v.size(); i++) ans += v[i].size();
cout << ans << '\n';
for (int i = v.size() - 1; i >= 0; i--) {
for (int j = 0; j < v[i].size(); j++)
cout << '(' << v[i][j].first << ',' << v[i][j].second << ") ";
cout << '\n';
}
return 0;
}
|
### Prompt
In cpp, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<vector<pair<int, int> > > v;
int main() {
ios ::sync_with_stdio(0);
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
cin >> n >> m >> k;
int r = 1, c = 1;
while (k--) {
v.push_back(vector<pair<int, int> >());
for (int i = 1; i <= r; i++) v.back().push_back(pair<int, int>(i, 1));
for (int i = 2; i <= c; i++) v.back().push_back(pair<int, int>(r, i));
if (k == 0) break;
do {
if (c == 1)
c = r + 1, r = 1;
else
r++, c--;
} while (r > n || c > m);
}
int ans = 0;
for (int i = 0; i < v.size(); i++) ans += v[i].size();
cout << ans << '\n';
for (int i = v.size() - 1; i >= 0; i--) {
for (int j = 0; j < v[i].size(); j++)
cout << '(' << v[i][j].first << ',' << v[i][j].second << ") ";
cout << '\n';
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
void path(int x, int y) {
int i = 1, j = 1;
while (j <= y) {
cout << "(" << 1 << "," << j << ")"
<< " ";
j++;
}
i++;
while (i <= x) {
cout << "(" << i << "," << y << ")"
<< " ";
i++;
}
cout << endl;
}
int mat[55][55];
map<int, vector<pair<int, int> > > m;
vector<pair<int, int> > v;
int main() {
int n, c, i, j, k, x, y;
scanf("%d %d %d", &n, &c, &k);
mat[1][1] = 1;
for (i = 1; i <= n; i++) {
for (j = 1; j <= c; j++) {
if (i == 1)
mat[i][j] = mat[i][j - 1] + 1;
else if (j == 1)
mat[i][j] = mat[i - 1][j] + 1;
else
mat[i][j] = min(mat[i - 1][j], mat[i][j - 1]) + 1;
m[mat[i][j]].push_back(make_pair(i, j));
}
}
j = 0;
int ans = 0;
i = 1;
while (1) {
if (j < k) {
for (int r = 0; r < m[i].size(); r++) {
j++;
ans += i;
v.push_back(make_pair(m[i][r].first, m[i][r].second));
if (j == k) break;
}
if (j == k) break;
} else
break;
i++;
}
cout << ans << endl;
reverse(v.begin(), v.end());
for (i = 0; i < v.size(); i++) {
path(v[i].first, v[i].second);
}
return 0;
}
|
### Prompt
Create a solution in CPP for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void path(int x, int y) {
int i = 1, j = 1;
while (j <= y) {
cout << "(" << 1 << "," << j << ")"
<< " ";
j++;
}
i++;
while (i <= x) {
cout << "(" << i << "," << y << ")"
<< " ";
i++;
}
cout << endl;
}
int mat[55][55];
map<int, vector<pair<int, int> > > m;
vector<pair<int, int> > v;
int main() {
int n, c, i, j, k, x, y;
scanf("%d %d %d", &n, &c, &k);
mat[1][1] = 1;
for (i = 1; i <= n; i++) {
for (j = 1; j <= c; j++) {
if (i == 1)
mat[i][j] = mat[i][j - 1] + 1;
else if (j == 1)
mat[i][j] = mat[i - 1][j] + 1;
else
mat[i][j] = min(mat[i - 1][j], mat[i][j - 1]) + 1;
m[mat[i][j]].push_back(make_pair(i, j));
}
}
j = 0;
int ans = 0;
i = 1;
while (1) {
if (j < k) {
for (int r = 0; r < m[i].size(); r++) {
j++;
ans += i;
v.push_back(make_pair(m[i][r].first, m[i][r].second));
if (j == k) break;
}
if (j == k) break;
} else
break;
i++;
}
cout << ans << endl;
reverse(v.begin(), v.end());
for (i = 0; i < v.size(); i++) {
path(v[i].first, v[i].second);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979;
const double eps = 1e-6;
const long long _INF = 1e18;
const int INF = 1e9;
const int maxn = 60;
const int maxm = 200000;
int n, m, k;
struct grid {
int x, y, c;
bool operator<(const grid &other) const { return this->c < other.c; }
} g[maxn * maxn];
int cal(int x, int y, bool f) {
int ret, i, j;
ret = i = j = 1;
if (f) printf("(1,1) ");
while (i < x) {
++i;
if (f) printf("(%d,%d) ", i, j);
++ret;
}
while (j < y) {
++j;
if (f) printf("(%d,%d) ", i, j);
++ret;
}
if (f) puts("");
return ret;
}
int main() {
while (~scanf("%d %d %d", &n, &m, &k)) {
int ans, tot;
ans = tot = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) g[tot++] = (grid){i, j, cal(i, j, false)};
sort(g, g + n * m);
for (int i = 0; i < k; ++i) ans += g[i].c;
printf("%d\n", ans);
for (int i = k - 1; i >= 0; --i) cal(g[i].x, g[i].y, true);
}
return 0;
}
|
### Prompt
Please create a solution in Cpp to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979;
const double eps = 1e-6;
const long long _INF = 1e18;
const int INF = 1e9;
const int maxn = 60;
const int maxm = 200000;
int n, m, k;
struct grid {
int x, y, c;
bool operator<(const grid &other) const { return this->c < other.c; }
} g[maxn * maxn];
int cal(int x, int y, bool f) {
int ret, i, j;
ret = i = j = 1;
if (f) printf("(1,1) ");
while (i < x) {
++i;
if (f) printf("(%d,%d) ", i, j);
++ret;
}
while (j < y) {
++j;
if (f) printf("(%d,%d) ", i, j);
++ret;
}
if (f) puts("");
return ret;
}
int main() {
while (~scanf("%d %d %d", &n, &m, &k)) {
int ans, tot;
ans = tot = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) g[tot++] = (grid){i, j, cal(i, j, false)};
sort(g, g + n * m);
for (int i = 0; i < k; ++i) ans += g[i].c;
printf("%d\n", ans);
for (int i = k - 1; i >= 0; --i) cal(g[i].x, g[i].y, true);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int n, m, k;
void print(int x, int y) {
for (int i = 1; i <= x; i++) printf("(%d,1) ", i);
for (int i = 2; i <= y; i++) printf("(%d,%d) ", x, i);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
vector<pair<int, int> > v;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!k) break;
int x = i, y = 1;
while (x >= 1 && y <= m && k > 0) {
k--;
v.push_back(make_pair(x, y));
ans += x + y - 1;
x--;
y++;
}
}
for (int i = 2; i <= m; i++) {
if (!k) break;
int x = n, y = i;
while (x >= 1 && y <= m && k > 0) {
k--;
v.push_back(make_pair(x, y));
ans += x + y - 1;
x--;
y++;
}
}
cout << ans << endl;
for (int i = v.size() - 1; i >= 0; i--) {
print(v[i].first, v[i].second);
puts("");
}
return 0;
}
|
### Prompt
Construct a CPP code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int n, m, k;
void print(int x, int y) {
for (int i = 1; i <= x; i++) printf("(%d,1) ", i);
for (int i = 2; i <= y; i++) printf("(%d,%d) ", x, i);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
vector<pair<int, int> > v;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!k) break;
int x = i, y = 1;
while (x >= 1 && y <= m && k > 0) {
k--;
v.push_back(make_pair(x, y));
ans += x + y - 1;
x--;
y++;
}
}
for (int i = 2; i <= m; i++) {
if (!k) break;
int x = n, y = i;
while (x >= 1 && y <= m && k > 0) {
k--;
v.push_back(make_pair(x, y));
ans += x + y - 1;
x--;
y++;
}
}
cout << ans << endl;
for (int i = v.size() - 1; i >= 0; i--) {
print(v[i].first, v[i].second);
puts("");
}
return 0;
}
```
|
#include <bits/stdc++.h>
const int N = 55;
using namespace std;
int n, m, k, g;
int d[N][N];
void fl(int x, int y) {
while (x <= n && y >= 1) {
g++;
d[x][y] = g;
x++;
y--;
}
}
bool cmp(pair<int, int> x, pair<int, int> y) {
return d[x.first][x.second] > d[y.first][y.second];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
int x = 1, y = 1;
for (int i = 1; i < n + m; i++) {
fl(x, y);
if (y == m)
x++;
else
y++;
}
vector<pair<int, int> > v;
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (d[i][j] <= k) {
v.push_back({i, j});
cnt += i + j - 1;
}
}
}
sort(v.begin(), v.end(), cmp);
cout << cnt << endl;
for (int i = 0; i < v.size(); i++) {
x = 1;
y = 1;
for (int j = 1; j < v[i].first + v[i].second; j++) {
cout << "(" << x << "," << y << ")"
<< " \n"[j == v[i].first + v[i].second - 1];
if (y == v[i].second)
x++;
else
y++;
}
}
}
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
const int N = 55;
using namespace std;
int n, m, k, g;
int d[N][N];
void fl(int x, int y) {
while (x <= n && y >= 1) {
g++;
d[x][y] = g;
x++;
y--;
}
}
bool cmp(pair<int, int> x, pair<int, int> y) {
return d[x.first][x.second] > d[y.first][y.second];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
int x = 1, y = 1;
for (int i = 1; i < n + m; i++) {
fl(x, y);
if (y == m)
x++;
else
y++;
}
vector<pair<int, int> > v;
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (d[i][j] <= k) {
v.push_back({i, j});
cnt += i + j - 1;
}
}
}
sort(v.begin(), v.end(), cmp);
cout << cnt << endl;
for (int i = 0; i < v.size(); i++) {
x = 1;
y = 1;
for (int j = 1; j < v[i].first + v[i].second; j++) {
cout << "(" << x << "," << y << ")"
<< " \n"[j == v[i].first + v[i].second - 1];
if (y == v[i].second)
x++;
else
y++;
}
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 128;
int n, m, k, ans;
vector<pair<int, int> > v[maxn], c;
void go(int x, int y, int a, int b) {
x++, y++, a++, b++;
while (x != a or y != b) {
printf("(%d,%d) ", x, y);
if (x == a)
y++;
else
x++;
}
printf("(%d,%d)\n", a, b);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) v[i + j].push_back(pair<int, int>(i, j));
for (int i = 0; i < n + m - 1 and c.size() < k; i++)
for (int j = 0; j < v[i].size() and c.size() < k; j++)
c.push_back(v[i][j]), ans += v[i][j].first + v[i][j].second + 1;
printf("%d\n", ans);
for (int i = k; i--;) go(0, 0, c[i].first, c[i].second);
return 0;
}
|
### Prompt
Construct a cpp code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 128;
int n, m, k, ans;
vector<pair<int, int> > v[maxn], c;
void go(int x, int y, int a, int b) {
x++, y++, a++, b++;
while (x != a or y != b) {
printf("(%d,%d) ", x, y);
if (x == a)
y++;
else
x++;
}
printf("(%d,%d)\n", a, b);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) v[i + j].push_back(pair<int, int>(i, j));
for (int i = 0; i < n + m - 1 and c.size() < k; i++)
for (int j = 0; j < v[i].size() and c.size() < k; j++)
c.push_back(v[i][j]), ans += v[i][j].first + v[i][j].second + 1;
printf("%d\n", ans);
for (int i = k; i--;) go(0, 0, c[i].first, c[i].second);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
stack<pair<int, int> > st;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n, m, p;
cin >> n >> m >> p;
int sum = 0;
for (int i = 2; i <= n + m; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++)
if (st.size() < p && j + k == i) {
sum += (j + k) - 1;
st.push(make_pair(j, k));
}
cout << sum << "\n";
while (!st.empty()) {
for (int i = 1; i <= st.top().second; i++)
cout << "(" << 1 << "," << i << ") ";
for (int i = 2; i <= st.top().first; i++)
cout << "(" << i << "," << st.top().second << ") ";
cout << "\n";
st.pop();
}
return 0;
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
stack<pair<int, int> > st;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n, m, p;
cin >> n >> m >> p;
int sum = 0;
for (int i = 2; i <= n + m; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++)
if (st.size() < p && j + k == i) {
sum += (j + k) - 1;
st.push(make_pair(j, k));
}
cout << sum << "\n";
while (!st.empty()) {
for (int i = 1; i <= st.top().second; i++)
cout << "(" << 1 << "," << i << ") ";
for (int i = 2; i <= st.top().first; i++)
cout << "(" << i << "," << st.top().second << ") ";
cout << "\n";
st.pop();
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<pair<int, int> > v;
int main() {
cin >> n >> m >> k;
for (int q = 2; q <= n + m; q++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i + j == q) {
k--;
v.push_back(make_pair(i, j));
}
if (k == 0) {
i = n + 1;
q = n + m + 1;
break;
}
}
}
}
int sum = 0;
for (int i = 0; i < v.size(); i++) {
sum += (v[i].first + v[i].second - 1);
}
cout << sum << endl;
for (int i = v.size() - 1; i >= 0; i--) {
int x = 1;
int y = 0;
while (y != v[i].second) {
y++;
cout << "(1," << y << ") ";
}
while (x != v[i].first) {
x++;
cout << "(" << x << "," << y << ") ";
}
cout << endl;
}
return 0;
}
|
### Prompt
Develop a solution in cpp to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<pair<int, int> > v;
int main() {
cin >> n >> m >> k;
for (int q = 2; q <= n + m; q++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i + j == q) {
k--;
v.push_back(make_pair(i, j));
}
if (k == 0) {
i = n + 1;
q = n + m + 1;
break;
}
}
}
}
int sum = 0;
for (int i = 0; i < v.size(); i++) {
sum += (v[i].first + v[i].second - 1);
}
cout << sum << endl;
for (int i = v.size() - 1; i >= 0; i--) {
int x = 1;
int y = 0;
while (y != v[i].second) {
y++;
cout << "(1," << y << ") ";
}
while (x != v[i].first) {
x++;
cout << "(" << x << "," << y << ") ";
}
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
int dist, x, y;
void out() { printf("(%d,%d) ", x, y); }
};
int n, m, k;
vector<Point> p;
void EXEC() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) p.push_back({i + j - 1, i, j});
partial_sort(p.begin(), p.begin() + k, p.end(),
[](Point &a, Point &b) { return a.dist < b.dist; });
p.erase(p.begin() + k, p.end());
reverse(p.begin(), p.end());
cout << accumulate(p.begin(), p.end(), 0, [](int &s, Point &x) {
return s + x.dist;
}) << endl;
for (auto i : p) {
Point t = {0, 1, 1};
t.out();
while (t.x < i.x) {
++t.x;
t.out();
}
while (t.y < i.y) {
++t.y;
t.out();
}
cout << endl;
}
}
int main() {
EXEC();
return 0;
}
|
### Prompt
Please formulate a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Point {
int dist, x, y;
void out() { printf("(%d,%d) ", x, y); }
};
int n, m, k;
vector<Point> p;
void EXEC() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) p.push_back({i + j - 1, i, j});
partial_sort(p.begin(), p.begin() + k, p.end(),
[](Point &a, Point &b) { return a.dist < b.dist; });
p.erase(p.begin() + k, p.end());
reverse(p.begin(), p.end());
cout << accumulate(p.begin(), p.end(), 0, [](int &s, Point &x) {
return s + x.dist;
}) << endl;
for (auto i : p) {
Point t = {0, 1, 1};
t.out();
while (t.x < i.x) {
++t.x;
t.out();
}
while (t.y < i.y) {
++t.y;
t.out();
}
cout << endl;
}
}
int main() {
EXEC();
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
stack<vector<pair<int, int> > > stk;
int n, m, k;
int ans = 0;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int l = 1; k > 0; l++) {
for (int i = 1; i <= n && k > 0; i++) {
int j = l - i + 1;
if (j <= 0 || j > m) continue;
vector<pair<int, int> > path;
for (int ii = 1; ii <= i; ii++) {
path.push_back(make_pair(ii, 1));
}
for (int jj = 2; jj <= j; jj++) {
path.push_back(make_pair(i, jj));
}
ans += path.size();
stk.push(path);
k--;
}
}
printf("%d\n", ans);
while (!stk.empty()) {
vector<pair<int, int> > tmp = stk.top();
stk.pop();
for (int i = 0; i < tmp.size(); i++) {
printf("(%d,%d) ", tmp[i].first, tmp[i].second);
}
printf("\n");
}
return 0;
}
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
stack<vector<pair<int, int> > > stk;
int n, m, k;
int ans = 0;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int l = 1; k > 0; l++) {
for (int i = 1; i <= n && k > 0; i++) {
int j = l - i + 1;
if (j <= 0 || j > m) continue;
vector<pair<int, int> > path;
for (int ii = 1; ii <= i; ii++) {
path.push_back(make_pair(ii, 1));
}
for (int jj = 2; jj <= j; jj++) {
path.push_back(make_pair(i, jj));
}
ans += path.size();
stk.push(path);
k--;
}
}
printf("%d\n", ans);
while (!stk.empty()) {
vector<pair<int, int> > tmp = stk.top();
stk.pop();
for (int i = 0; i < tmp.size(); i++) {
printf("(%d,%d) ", tmp[i].first, tmp[i].second);
}
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct el {
int x, y, prev, cnt;
};
el q[111111];
int n, m, k, ans, a[111][111];
void getback(int k) {
if (q[k].prev != -1) getback(q[k].prev);
cout << "(" << q[k].x << "," << q[k].y << ") ";
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = 0;
ans = 0;
q[0].x = 1;
q[0].y = 1;
q[0].prev = -1;
q[0].cnt = 1;
int un = 0;
int uk = 1;
while (k != 0) {
el w = q[un];
ans += w.cnt;
un++;
k--;
if (w.x + 1 <= n && a[w.x + 1][w.y] == 0) {
q[uk] = w;
q[uk].x++;
q[uk].cnt++;
q[uk].prev = un - 1;
a[w.x + 1][w.y] = 1;
uk++;
}
if (w.y + 1 <= m && a[w.x][w.y + 1] == 0) {
q[uk] = w;
q[uk].y++;
q[uk].cnt++;
q[uk].prev = un - 1;
a[w.x][w.y + 1] = 1;
uk++;
}
}
cout << ans << endl;
for (int i = un - 1; i >= 0; i--) {
getback(i);
cout << endl;
}
return 0;
}
|
### Prompt
In Cpp, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct el {
int x, y, prev, cnt;
};
el q[111111];
int n, m, k, ans, a[111][111];
void getback(int k) {
if (q[k].prev != -1) getback(q[k].prev);
cout << "(" << q[k].x << "," << q[k].y << ") ";
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = 0;
ans = 0;
q[0].x = 1;
q[0].y = 1;
q[0].prev = -1;
q[0].cnt = 1;
int un = 0;
int uk = 1;
while (k != 0) {
el w = q[un];
ans += w.cnt;
un++;
k--;
if (w.x + 1 <= n && a[w.x + 1][w.y] == 0) {
q[uk] = w;
q[uk].x++;
q[uk].cnt++;
q[uk].prev = un - 1;
a[w.x + 1][w.y] = 1;
uk++;
}
if (w.y + 1 <= m && a[w.x][w.y + 1] == 0) {
q[uk] = w;
q[uk].y++;
q[uk].cnt++;
q[uk].prev = un - 1;
a[w.x][w.y + 1] = 1;
uk++;
}
}
cout << ans << endl;
for (int i = un - 1; i >= 0; i--) {
getback(i);
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(vector<pair<int, int>>& a, vector<pair<int, int>>& b) {
return a.size() < b.size();
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int put = max(n, m) * max(n, m);
int all = 1;
int horizontal = 1, vertical = 1;
vector<vector<pair<int, int>>> v;
vector<pair<int, int>> moves;
while (1) {
for (int i = 0; i < all - 1; i++) {
moves.clear();
for (int j = 0; j < horizontal; j++) moves.push_back({j + 1, 1});
for (int j = 0; j < i; j++) moves.push_back({horizontal, j + 2});
v.push_back(moves);
put--;
if (put == 0) goto there;
moves.clear();
for (int j = 0; j < vertical; j++) moves.push_back({1, j + 1});
for (int j = 0; j < i; j++) moves.push_back({j + 2, horizontal});
put--;
v.push_back(moves);
if (put == 0) goto there;
}
moves.clear();
for (int j = 0; j < horizontal; j++) moves.push_back({j + 1, 1});
for (int j = 0; j < vertical - 1; j++) moves.push_back({horizontal, j + 2});
v.push_back(moves);
put--;
if (put == 0) goto there;
all++;
horizontal++;
vertical++;
}
there:
vector<vector<pair<int, int>>> ans;
sort(v.begin(), v.end(), cmp);
for (auto i : v) {
bool ok = 1;
for (auto j : i)
if (j.first > n || j.second > m) {
ok = 0;
break;
}
if (ok) k--, ans.push_back(i);
if (k == 0) break;
}
int pen = 0;
reverse(ans.begin(), ans.end());
for (auto i : ans) pen += i.size();
cout << pen << '\n';
for (auto i : ans) {
for (int j = 0; j < i.size(); j++) {
cout << '(' << i[j].first << "," << i[j].second << ")";
if (j != i.size() - 1) cout << " ";
}
cout << '\n';
}
}
|
### Prompt
Please formulate a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool cmp(vector<pair<int, int>>& a, vector<pair<int, int>>& b) {
return a.size() < b.size();
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int put = max(n, m) * max(n, m);
int all = 1;
int horizontal = 1, vertical = 1;
vector<vector<pair<int, int>>> v;
vector<pair<int, int>> moves;
while (1) {
for (int i = 0; i < all - 1; i++) {
moves.clear();
for (int j = 0; j < horizontal; j++) moves.push_back({j + 1, 1});
for (int j = 0; j < i; j++) moves.push_back({horizontal, j + 2});
v.push_back(moves);
put--;
if (put == 0) goto there;
moves.clear();
for (int j = 0; j < vertical; j++) moves.push_back({1, j + 1});
for (int j = 0; j < i; j++) moves.push_back({j + 2, horizontal});
put--;
v.push_back(moves);
if (put == 0) goto there;
}
moves.clear();
for (int j = 0; j < horizontal; j++) moves.push_back({j + 1, 1});
for (int j = 0; j < vertical - 1; j++) moves.push_back({horizontal, j + 2});
v.push_back(moves);
put--;
if (put == 0) goto there;
all++;
horizontal++;
vertical++;
}
there:
vector<vector<pair<int, int>>> ans;
sort(v.begin(), v.end(), cmp);
for (auto i : v) {
bool ok = 1;
for (auto j : i)
if (j.first > n || j.second > m) {
ok = 0;
break;
}
if (ok) k--, ans.push_back(i);
if (k == 0) break;
}
int pen = 0;
reverse(ans.begin(), ans.end());
for (auto i : ans) pen += i.size();
cout << pen << '\n';
for (auto i : ans) {
for (int j = 0; j < i.size(); j++) {
cout << '(' << i[j].first << "," << i[j].second << ")";
if (j != i.size() - 1) cout << " ";
}
cout << '\n';
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005;
struct node {
int x, y;
bool operator<(const node &b) const { return x + y < b.x + b.y; }
} p[maxn];
int n, m, k;
int main() {
int c(0);
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p[c].x = i;
p[c].y = j;
c++;
}
}
sort(p, p + c);
int ans(0);
for (int i = 0; i < k; i++) ans += p[i].x + p[i].y - 1;
printf("%d\n", ans);
for (int i = k - 1; i >= 0; i--) {
for (int j = 1; j <= p[i].x; j++) printf("(%d,1) ", j);
for (int j = 2; j <= p[i].y; j++) printf("(%d,%d) ", p[i].x, j);
printf("\n");
}
return 0;
}
|
### Prompt
Generate a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005;
struct node {
int x, y;
bool operator<(const node &b) const { return x + y < b.x + b.y; }
} p[maxn];
int n, m, k;
int main() {
int c(0);
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p[c].x = i;
p[c].y = j;
c++;
}
}
sort(p, p + c);
int ans(0);
for (int i = 0; i < k; i++) ans += p[i].x + p[i].y - 1;
printf("%d\n", ans);
for (int i = k - 1; i >= 0; i--) {
for (int j = 1; j <= p[i].x; j++) printf("(%d,1) ", j);
for (int j = 2; j <= p[i].y; j++) printf("(%d,%d) ", p[i].x, j);
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int D[250], Put[250], N, M, K;
int main() {
cin >> N >> M >> K;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) {
int d = i - 1 + j - 1;
D[d]++;
}
int ans = 0;
for (int i = 0; i <= N + M - 2; i++) {
Put[i] = min(D[i], K - D[i - 1]);
ans += Put[i] * (i + 1);
D[i] = D[i - 1] + D[i];
if (D[i] >= K) break;
}
cout << ans << "\n";
for (int i = N + M - 2; i >= 0; i--) {
int rem = Put[i];
int x = min(N, i + 1);
int y = i - (x - 1) + 1;
while (rem) {
for (int p = 1; p < y; p++) cout << "(" << 1 << "," << p << ") ";
for (int p = 1; p < x; p++) cout << "(" << p << "," << y << ") ";
cout << "(" << x << "," << y << ")\n";
x--, y++, rem--;
}
}
}
|
### Prompt
In CPP, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int D[250], Put[250], N, M, K;
int main() {
cin >> N >> M >> K;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) {
int d = i - 1 + j - 1;
D[d]++;
}
int ans = 0;
for (int i = 0; i <= N + M - 2; i++) {
Put[i] = min(D[i], K - D[i - 1]);
ans += Put[i] * (i + 1);
D[i] = D[i - 1] + D[i];
if (D[i] >= K) break;
}
cout << ans << "\n";
for (int i = N + M - 2; i >= 0; i--) {
int rem = Put[i];
int x = min(N, i + 1);
int y = i - (x - 1) + 1;
while (rem) {
for (int p = 1; p < y; p++) cout << "(" << 1 << "," << p << ") ";
for (int p = 1; p < x; p++) cout << "(" << p << "," << y << ") ";
cout << "(" << x << "," << y << ")\n";
x--, y++, rem--;
}
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, k;
vector<pair<int, vector<pair<int, int> > > > ans;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
vector<pair<int, int> > ret;
for (int y = 1; y <= j; y++) ret.push_back(make_pair(1, y));
for (int x = 2; x <= i; x++) {
ret.push_back(make_pair(x, j));
}
ans.push_back(make_pair(i + j, ret));
}
}
sort(ans.begin(), ans.end());
int ret = 0;
for (int i = 0; i < k; i++) {
ret += ans[i].second.size();
}
cout << ret << endl;
for (int i = k - 1; i >= 0; i--) {
vector<pair<int, int> > t = ans[i].second;
for (int j = 0; j < t.size(); j++) {
cout << "(" << t[j].first << "," << t[j].second << ") ";
}
cout << endl;
}
return 0;
}
|
### Prompt
Please create a solution in CPP to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, k;
vector<pair<int, vector<pair<int, int> > > > ans;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
vector<pair<int, int> > ret;
for (int y = 1; y <= j; y++) ret.push_back(make_pair(1, y));
for (int x = 2; x <= i; x++) {
ret.push_back(make_pair(x, j));
}
ans.push_back(make_pair(i + j, ret));
}
}
sort(ans.begin(), ans.end());
int ret = 0;
for (int i = 0; i < k; i++) {
ret += ans[i].second.size();
}
cout << ret << endl;
for (int i = k - 1; i >= 0; i--) {
vector<pair<int, int> > t = ans[i].second;
for (int j = 0; j < t.size(); j++) {
cout << "(" << t[j].first << "," << t[j].second << ") ";
}
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<pair<int, pair<int, int> > > has;
int res;
void Print(int r, int c) {
bool pr = false;
for (int j = 1; j <= c; j++) {
printf("%s(%d,%d)", pr ? " " : "", 1, j);
pr = true;
}
for (int i = 2; i <= r; i++) {
printf("%s(%d,%d)", pr ? " " : "", i, c);
pr = true;
}
printf("\n");
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
has.push_back(
pair<int, pair<int, int> >(i + j - 1, pair<int, int>(i, j)));
sort(has.begin(), has.end());
for (int i = 0; i < k; i++) res += has[i].first;
printf("%d\n", res);
for (int i = k - 1; i >= 0; i--)
Print(has[i].second.first, has[i].second.second);
return 0;
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<pair<int, pair<int, int> > > has;
int res;
void Print(int r, int c) {
bool pr = false;
for (int j = 1; j <= c; j++) {
printf("%s(%d,%d)", pr ? " " : "", 1, j);
pr = true;
}
for (int i = 2; i <= r; i++) {
printf("%s(%d,%d)", pr ? " " : "", i, c);
pr = true;
}
printf("\n");
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
has.push_back(
pair<int, pair<int, int> >(i + j - 1, pair<int, int>(i, j)));
sort(has.begin(), has.end());
for (int i = 0; i < k; i++) res += has[i].first;
printf("%d\n", res);
for (int i = k - 1; i >= 0; i--)
Print(has[i].second.first, has[i].second.second);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int TAM = 30000 + 15;
const long long MOD = 1000000007LL;
const double PI = 3.14159265359;
long long add(long long x, long long y) { return (x + y + 2 * MOD) % MOD; }
long long mult(long long x, long long y) {
return (add(x, 0) * add(y, 0)) % MOD;
}
long long fast_expo(long long x, long long y) {
if (x == 0) return 0;
if (y == 0) return 1;
long long res = 1;
long long mid = fast_expo(x, y / 2);
if (y % 2 != 0) res = x;
return mult(mult(mid, mid), res);
}
long long inver(long long x) { return fast_expo(x, MOD - 2); }
long long gcd(long long e1, long long e2) {
if (e2 == 0) return e1;
return gcd(e2, e1 % e2);
}
vector<vector<int> > v;
void llegar(int x, int y) {
for (int i = 1; i <= x; i++) {
printf("(%d, 1) ", i);
}
for (int j = 2; j <= y; j++) {
printf("(%d, %d) ", x, j);
}
puts("");
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int cost = 0;
vector<int> d(3);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
d[0] = i + j - 1;
d[1] = i;
d[2] = j;
v.push_back(d);
}
}
sort(v.begin(), v.end());
for (int i = 0; i < k; i++) cost += v[i][0];
cout << cost << endl;
for (int i = k - 1; i >= 0; i--) {
llegar(v[i][1], v[i][2]);
}
return 0;
}
|
### Prompt
In cpp, your task is to solve the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int TAM = 30000 + 15;
const long long MOD = 1000000007LL;
const double PI = 3.14159265359;
long long add(long long x, long long y) { return (x + y + 2 * MOD) % MOD; }
long long mult(long long x, long long y) {
return (add(x, 0) * add(y, 0)) % MOD;
}
long long fast_expo(long long x, long long y) {
if (x == 0) return 0;
if (y == 0) return 1;
long long res = 1;
long long mid = fast_expo(x, y / 2);
if (y % 2 != 0) res = x;
return mult(mult(mid, mid), res);
}
long long inver(long long x) { return fast_expo(x, MOD - 2); }
long long gcd(long long e1, long long e2) {
if (e2 == 0) return e1;
return gcd(e2, e1 % e2);
}
vector<vector<int> > v;
void llegar(int x, int y) {
for (int i = 1; i <= x; i++) {
printf("(%d, 1) ", i);
}
for (int j = 2; j <= y; j++) {
printf("(%d, %d) ", x, j);
}
puts("");
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int cost = 0;
vector<int> d(3);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
d[0] = i + j - 1;
d[1] = i;
d[2] = j;
v.push_back(d);
}
}
sort(v.begin(), v.end());
for (int i = 0; i < k; i++) cost += v[i][0];
cout << cost << endl;
for (int i = k - 1; i >= 0; i--) {
llegar(v[i][1], v[i][2]);
}
return 0;
}
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.