text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60000000")
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
int n, m, k;
char a[50][50];
const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, 1, -1};
bool u[256];
int d[50][50];
pair<int, int> q[2500];
string bfs() {
memset(d, 255, sizeof(d));
pair<int, int> S, T;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(m); j++) {
if (a[i][j] == 'S') S = make_pair(i, j);
if (a[i][j] == 'T') T = make_pair(i, j);
}
d[T.first][T.second] = 0;
int h, t;
h = t = 0;
q[h] = T;
while (h <= t) {
pair<int, int> v = q[h];
h++;
for (int i = 0; i < (int)(4); i++) {
pair<int, int> w = make_pair(v.first + dx[i], v.second + dy[i]);
if (0 <= w.first && w.first < n && 0 <= w.second && w.second < m &&
d[w.first][w.second] == -1 && u[a[w.first][w.second]]) {
d[w.first][w.second] = d[v.first][v.second] + 1;
t++;
q[t] = w;
}
}
}
if (d[S.first][S.second] == -1) return "S";
string res = "";
vector<pair<int, int> > V, W;
V.push_back(S);
int cd = d[S.first][S.second];
while (cd > 1) {
char c = 'z';
for (int i = 0; i < (int)(V.size()); i++)
for (int j = 0; j < (int)(4); j++) {
pair<int, int> w = make_pair(V[i].first + dx[j], V[i].second + dy[j]);
if (0 <= w.first && w.first < n && 0 <= w.second && w.second < m &&
cd - 1 == d[w.first][w.second])
c = min(c, a[w.first][w.second]);
}
res += c;
W.clear();
for (int i = 0; i < (int)(V.size()); i++)
for (int j = 0; j < (int)(4); j++) {
pair<int, int> w = make_pair(V[i].first + dx[j], V[i].second + dy[j]);
if (0 <= w.first && w.first < n && 0 <= w.second && w.second < m &&
cd - 1 == d[w.first][w.second] && a[w.first][w.second] == c)
W.push_back(w);
}
sort(W.begin(), W.end());
W.resize(unique(W.begin(), W.end()) - W.begin());
cd--;
V = W;
W.clear();
}
return res;
}
string res;
void calc(int cur, int la) {
if (cur == 26) {
string tmp = bfs();
if (tmp == "S") return;
if (res == "S")
res = tmp;
else if (res.length() > tmp.length() ||
(res.length() == tmp.length() && res > tmp))
res = tmp;
return;
}
calc(cur + 1, la);
if (la == 0) return;
u[cur + 'a'] = 1;
calc(cur + 1, la - 1);
u[cur + 'a'] = 0;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(m); j++) cin >> a[i][j];
memset(u, 0, sizeof(u));
u['S'] = 1;
u['T'] = 1;
res = "S";
calc(0, k);
if (res == "S")
cout << -1 << endl;
else
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bcount[1 << 12];
set<pair<int, int> > done;
string Map[60];
int n, m, k;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int ex, ey;
int absval(int x) { return x < 0 ? -x : x; }
int dist(int ax, int ay, int bx, int by) {
return absval(ax - bx) + absval(ay - by);
}
struct pqitem {
int x, y;
string S;
int mask;
bool operator<(const pqitem &b) const {
if (S.size() + dist(x, y, ex, ey) == b.S.size() + dist(b.x, b.y, ex, ey) &&
S.compare(b.S) > 0)
return S.compare(b.S) > 0;
else
return S.size() + dist(x, y, ex, ey) >
b.S.size() + dist(b.x, b.y, ex, ey);
}
};
int getbcount(int m) {
int ret = 0;
while (m > 0) {
ret += bcount[m & ((1 << 10) - 1)];
m >>= 10;
}
return ret;
}
int main() {
for (int i = 1; i <= (1 << 10); i++)
bcount[i] = bcount[i / 2] + (i & 1 ? 1 : 0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> Map[i];
int x, y;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (Map[i][j] == 'S') x = i, y = j;
if (Map[i][j] == 'T') ex = i, ey = j;
}
priority_queue<pqitem> q;
q.push((pqitem){x, y, "", 0});
bool found = false;
while (!q.empty()) {
pqitem cur = q.top();
q.pop();
if (cur.x == ex && cur.y == ey) {
cout << cur.S << endl;
found = true;
break;
}
if (done.find(make_pair(cur.x * m + cur.y, cur.mask)) != done.end())
continue;
done.insert(make_pair(cur.x * m + cur.y, cur.mask));
for (int d = 0; d < 4; d++) {
pqitem nxt = cur;
nxt.x += dx[d];
nxt.y += dy[d];
if (!(nxt.x >= 0 && nxt.x <= n - 1 && nxt.y >= 0 && nxt.y <= m - 1))
continue;
if (Map[nxt.x][nxt.y] != 'T') {
nxt.mask |= (1 << (Map[nxt.x][nxt.y] - 'a'));
nxt.S += Map[nxt.x][nxt.y];
}
if (getbcount(nxt.mask) <= k) q.push(nxt);
}
}
if (!found) printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int R, C, KK;
char ssG[N][N];
int stx, sty;
struct nodexx {
string str;
int x, y, val;
nodexx(string str00, int x00, int y00, int val00) {
str = str00, x = x00, y = y00, val = val00;
}
bool operator<(const nodexx t) const {
int lenaa = str.size(), lenbb = t.str.size();
if (lenaa - lenbb) return lenaa > lenbb;
return str > t.str;
}
};
priority_queue<nodexx> QQ;
set<pair<pair<int, int>, int> > SET;
int has[N][N];
int dirc[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
bool Judge(int x) {
int cnt = 0;
while (x > 0) {
cnt += x % 2;
x >>= 1;
}
return cnt <= KK;
}
string BFS() {
SET.clear();
memset(has, 0, sizeof has);
while (QQ.size()) QQ.pop();
QQ.push(nodexx("", stx, sty, 0));
SET.insert(make_pair(make_pair(stx, sty), 0));
int e, r, c, t;
while (QQ.size()) {
nodexx XA = QQ.top();
QQ.pop();
for (e = 0; e < 4; e++) {
r = XA.x + dirc[e][0], c = XA.y + dirc[e][1];
if (r >= 0 && r < R && c >= 0 && c < C && ssG[r][c] != 'S') {
if (ssG[r][c] == 'T') return XA.str;
t = XA.val | (1 << (ssG[r][c] - 'a'));
if (Judge(t) && SET.count(make_pair(make_pair(r, c), t)) == 0) {
if (has[r][c] && (has[r][c] & t) == has[r][c]) continue;
has[r][c] = t;
SET.insert(make_pair(make_pair(r, c), t));
QQ.push(nodexx(XA.str + ssG[r][c], r, c, t));
}
}
}
}
return "-1";
}
void cyh() { cout << BFS() << endl; }
int main() {
int e, f;
while (cin >> R >> C >> KK) {
for (e = 0; e < R; e++) {
scanf("%s", ssG[e]);
for (f = 0; f < C; f++)
if (ssG[e][f] == 'S') stx = e, sty = f;
}
cyh();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int dy[4] = {0, 0, -1, 1};
const int dx[4] = {1, -1, 0, 0};
int n, m, k;
vector<string> s;
pair<int, string> answ;
bool us[26];
void get_way() {
int d[50][50];
bool used[50][50];
pair<int, int> from[50][50];
int sy, sx, ty, tx;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
d[i][j] = 1000000000;
if (s[i][j] == 'S') {
sy = i;
sx = j;
}
if (s[i][j] == 'T') {
ty = i;
tx = j;
}
used[i][j] = false;
}
d[ty][tx] = 0;
queue<pair<int, int> > q;
q.push(make_pair(ty, tx));
while (!q.empty()) {
int cury = q.front().first;
int curx = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int toy = cury + dy[i];
int tox = curx + dx[i];
if (toy >= 0 && toy < n && tox >= 0 && tox < m && d[toy][tox] == INF) {
if (s[toy][tox] != 'S' && s[toy][tox] != 'T' && !us[s[toy][tox] - 'a'])
continue;
d[toy][tox] = d[cury][curx] + 1;
q.push(make_pair(toy, tox));
}
}
}
if (d[sy][sx] == INF) return;
vector<pair<int, int> > st, st2;
st.push_back(make_pair(sy, sx));
used[sy][sx] = true;
while (true) {
for (int i = 0; i < st.size(); i++) {
int cury = st[i].first;
int curx = st[i].second;
for (int j = 0; j < 4; j++) {
int toy = cury + dy[j];
int tox = curx + dx[j];
if (toy >= 0 && toy < n && tox >= 0 && tox < m &&
d[cury][curx] - d[toy][tox] == 1 && !used[toy][tox]) {
used[toy][tox] = true;
from[toy][tox] = make_pair(cury, curx);
if (st2.size() == 0) {
st2.push_back(make_pair(toy, tox));
} else {
if (s[toy][tox] < s[st2[0].first][st2[0].second]) {
st2.clear();
st2.push_back(make_pair(toy, tox));
} else if (s[toy][tox] == s[st2[0].first][st2[0].second]) {
st2.push_back(make_pair(toy, tox));
}
}
}
}
}
st = st2;
st2.clear();
if (st.size() == 0) break;
}
string ans = "";
int cy = ty, cx = tx;
while (true) {
int tty = from[cy][cx].first;
int ttx = from[cy][cx].second;
if (tty == sy && ttx == sx) break;
ans += s[tty][ttx];
cy = tty;
cx = ttx;
}
reverse(ans.begin(), ans.end());
if (d[sy][sx] < answ.first) {
answ = make_pair(d[sy][sx], ans);
} else if (d[sy][sx] == answ.first && ans < answ.second) {
answ = make_pair(d[sy][sx], ans);
}
}
void rec(int cur, int cnt) {
if (cnt == k) {
get_way();
return;
}
for (int i = cur; i < 26; i++) {
us[i] = true;
rec(i + 1, cnt + 1);
us[i] = false;
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
s.push_back(str);
}
answ = make_pair(INF, "");
rec(0, 0);
if (answ.first == INF) {
cout << -1;
} else
cout << answ.second;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 52;
int n, m, k;
char s[maxN][maxN];
int d[maxN][maxN];
char f[maxN][maxN];
int px[maxN][maxN], py[maxN][maxN];
bool allowed[maxN];
string res;
int length = 1000000;
int sx, sy;
int fx, fy;
bool isOk(int x, int y) {
return 0 <= x && x < n && 0 <= y && y < m &&
(s[x][y] == 'S' || s[x][y] == 'T' || allowed[s[x][y] - 'a']);
}
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
void check() {
queue<pair<int, int> > q;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
d[i][j] = 1000000000;
f[i][j] = 'z';
}
}
q.push(make_pair(fx, fy));
d[fx][fy] = 0;
while (!q.empty()) {
pair<int, int> current = q.front();
q.pop();
int x = current.first;
int y = current.second;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (isOk(nx, ny) && d[nx][ny] > d[x][y] + 1) {
d[nx][ny] = d[x][y] + 1;
f[nx][ny] = s[x][y];
px[nx][ny] = x;
py[nx][ny] = y;
q.push(make_pair(nx, ny));
} else if (isOk(nx, ny) && d[nx][ny] == d[x][y] + 1) {
if (s[x][y] < f[nx][ny]) {
f[nx][ny] = s[x][y];
px[nx][ny] = x;
py[nx][ny] = y;
}
}
}
}
if (d[sx][sy] - 1 > length) {
return;
}
string current = "";
int x = sx;
int y = sy;
vector<pair<int, int> > candidates;
candidates.push_back(make_pair(x, y));
int len = d[x][y];
while (len > 1) {
vector<pair<int, int> > ncandidates;
char value = 'z';
for (int i = 0; i < candidates.size(); ++i) {
int cx = candidates[i].first;
int cy = candidates[i].second;
for (int j = 0; j < 4; ++j) {
int nx = cx + dx[j];
int ny = cy + dy[j];
if (isOk(nx, ny) && d[nx][ny] + 1 == d[cx][cy]) {
if (s[nx][ny] < value) {
ncandidates.clear();
ncandidates.push_back(make_pair(nx, ny));
value = s[nx][ny];
} else if (s[nx][ny] == value) {
ncandidates.push_back(make_pair(nx, ny));
}
}
}
}
current += value;
sort(ncandidates.begin(), ncandidates.end());
candidates = ncandidates;
candidates.resize(unique(candidates.begin(), candidates.end()) -
candidates.begin());
--len;
}
if (current.size() < length || (current.size() == length && current < res)) {
length = current.size();
res = current;
}
}
void rec(int index, int cnt) {
if (cnt <= k) {
check();
}
if (cnt == k) {
return;
}
for (int i = index; i < 26; ++i) {
allowed[i] = true;
rec(i + 1, cnt + 1);
allowed[i] = false;
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (s[i][j] == 'S') {
sx = i;
sy = j;
}
if (s[i][j] == 'T') {
fx = i;
fy = j;
}
}
}
rec(0, 0);
if (length == 1000000) {
cout << -1 << endl;
return 0;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
os << "{" << p.first << ", " << p.second << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[";
int i = 0;
for (typename vector<T>::const_iterator it = p.begin(); it != p.end(); ++it) {
os << (i == 0 ? "" : ", ") << *it;
i++;
}
os << "]";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[";
int i = 0;
for (typename set<T>::const_iterator it = p.begin(); it != p.end(); ++it) {
os << (i == 0 ? "" : ", ") << *it;
i++;
}
os << "]";
return os;
}
template <class K, class V>
ostream& operator<<(ostream& os, const map<K, V>& p) {
os << "[";
int i = 0;
for (typename map<K, V>::const_iterator it = p.begin(); it != p.end(); ++it) {
os << (i == 0 ? "" : ", ") << *it;
i++;
}
os << "]";
return os;
}
template <class T>
string toString(const T& o) {
stringstream ss;
ss << o;
string ret;
getline(ss, ret);
return ret;
}
template <class T>
vector<T> subv(const vector<T>& v, int from, int to) {
return vector<T>(v.begin() + min(max(0, from), (int)v.size()),
v.begin() + min(max(0, to), (int)v.size()));
}
pair<int, int> operator+(const pair<int, int>& a, const pair<int, int>& b) {
return make_pair(a.first + b.first, a.second + b.second);
}
pair<int, int> operator*(const int& a, const pair<int, int>& b) {
return make_pair(a * b.first, a * b.second);
}
vector<vector<int> > a;
int si, sj, ti, tj;
int f[64][64];
int n, m;
int d[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int c1, c2, c3, c4;
void go() {
queue<pair<int, int> > q;
queue<int> st;
q.push(make_pair(si, sj));
st.push(1);
while (q.size()) {
pair<int, int> p = q.front();
q.pop();
int step = st.front();
st.pop();
if (f[p.first][p.second] != 0) continue;
f[p.first][p.second] = step;
step++;
for (int k = 0; k < 4; ++k) {
int x = p.first + d[k][0];
int y = p.second + d[k][1];
if (0 <= x && x < n && 0 <= y && y < m) {
int& v = a[x][y];
bool ok = (v == c1 || v == c2 || v == c3 || v == c4);
if (v < 0 || ok)
if (f[x][y] == 0) {
q.push(make_pair(x, y));
st.push(step);
}
}
}
}
}
int best_len = -1;
string best_path = "";
string short_path = "";
vector<vector<string> > paths;
string path(int x, int y) {
string& ret = paths[x][y];
if (ret != "") return ret;
if (x == ti && y == tj) {
ret = "T";
return ret;
}
int fd = f[x][y];
string tmp = "";
for (int k = 0; k < 4; ++k) {
int xx = x + d[k][0];
int yy = y + d[k][1];
if (0 <= xx && xx < n && 0 <= yy && yy < m && f[xx][yy] == f[x][y] + 1) {
string r = path(xx, yy);
if (r != "X" && (tmp == "" || r < tmp)) tmp = r;
}
}
if (tmp == "")
ret = "X";
else {
char c = ((x == si && y == sj) ? 'S' : (a[x][y] + 'a'));
ret = c + tmp;
}
return ret;
}
vector<int> ch;
vector<vector<int> > comb;
vector<string> scomb;
void combination(int pos, int len, vector<int> v) {
if (len == 0) comb.push_back(v);
if (len == 0 || len > pos + 1) return;
combination(pos - 1, len, v);
v.push_back(ch[pos]);
combination(pos - 1, len - 1, v);
}
int main() {
int k;
cin >> n >> m >> k;
if (n * m == 2) {
cout << endl;
return 0;
}
a = vector<vector<int> >(n, vector<int>(m, 0));
paths.resize(n, vector<string>(m, ""));
vector<vector<string> > old = paths;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int j = 0; j < m; ++j) {
if (s[j] == 'S') {
si = i;
sj = j;
a[i][j] = -1;
} else if (s[j] == 'T') {
ti = i;
tj = j;
a[i][j] = -2;
} else {
a[i][j] = s[j] - 'a';
ch.push_back(a[i][j]);
}
}
}
sort(ch.begin(), ch.end());
ch.resize(unique(ch.begin(), ch.end()) - ch.begin());
k = min(k, (int)ch.size());
combination(ch.size() - 1, k, vector<int>());
for (int i = 0; i < comb.size(); ++i) {
string s = "";
for (int j = 0; j < comb[i].size(); ++j) s += (comb[i][j] + 'a');
sort(s.begin(), s.end());
scomb.push_back(s);
}
vector<int> pw(26, 0);
for (int i = 0; i < 26; ++i) pw[i] = (1 << i);
for (int i = 0; i < comb.size(); ++i) {
c1 = c2 = c3 = c4 = -100;
int sz = comb[i].size();
c1 = comb[i][0];
if (sz > 1) c2 = comb[i][1];
if (sz > 2) c3 = comb[i][2];
if (sz > 3) c4 = comb[i][3];
memset(f, 0, sizeof(f));
go();
if (f[ti][tj] == 0) continue;
if (best_len != -1 && f[ti][tj] > best_len) continue;
if (f[ti][tj] == best_len)
if (*short_path.rbegin() <= scomb[i][0]) continue;
paths = old;
path(si, sj);
string& cand = paths[si][sj];
if ((best_len == -1 || cand.size() < best_len) ||
(cand.size() == best_len && cand < best_path)) {
best_len = cand.size();
best_path = cand;
cand = string(cand.begin() + 1, cand.end() - 1);
sort(cand.begin(), cand.end());
cand.resize(unique(cand.begin(), cand.end()) - cand.begin());
short_path = cand;
}
}
if (best_len == -1)
cout << -1 << endl;
else {
string& s = best_path;
cout << string(s.begin() + 1, s.end() - 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m, K, sx, sy, ex, ey;
char s[N][N];
vector<char> has;
vector<int> ok;
bool fd = false;
string ans;
int len = 1 << 20;
pair<int, int> pre[N][N];
int rk[N][N];
bool O[300];
const int inf = 1 << 30;
bool Cmp(const pair<int, int>& a, const pair<int, int>& b) {
if (rk[a.first][a.second] != rk[b.first][b.second])
return rk[a.first][a.second] < rk[b.first][b.second];
return s[a.first][a.second] < s[b.first][b.second];
}
bool same(const pair<int, int>& a, const pair<int, int>& b) {
return s[a.first][a.second] == s[b.first][b.second] &&
rk[a.first][a.second] == rk[b.first][b.second];
}
int tmp[N * N];
void solve() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) rk[i][j] = inf;
vector<pair<int, int> > Q;
Q.push_back(make_pair(sx, sy));
rk[sx][sy] = 0;
for (int i = 0; i < (int)(ok).size(); ++i) O[ok[i]] = true;
int L = 0;
O[(int)'T'] = true;
while ((int)(Q).size()) {
vector<pair<int, int> > P;
for (int i = 0; i < (int)(Q).size(); ++i) {
int x = Q[i].first, y = Q[i].second;
for (int d = 0; d < 4; ++d) {
int nx = x + (d == 2) - (d == 0);
int ny = y + (d == 3) - (d == 1);
if (0 <= nx && nx < n && 0 <= ny && ny < m && O[(int)s[nx][ny]] &&
rk[nx][ny] > rk[x][y]) {
if (rk[nx][ny] == inf) P.push_back(make_pair(nx, ny));
rk[nx][ny] = rk[x][y];
pre[nx][ny] = make_pair(x, y);
}
}
}
sort((P).begin(), (P).end(), Cmp);
tmp[0] = ++L;
for (int i = 1; i < (int)(P).size(); ++i)
tmp[i] = same(P[i], P[i - 1]) ? tmp[i - 1] : ++L;
for (int i = 0; i < (int)(P).size(); ++i)
rk[P[i].first][P[i].second] = tmp[i];
swap(Q, P);
}
for (int i = 0; i < (int)(ok).size(); ++i) O[ok[i]] = false;
if (rk[ex][ey] == inf) return;
fd = true;
string S;
for (int i = ex, j = ey; i != sx || j != sy;) {
S += s[i][j];
int ni = pre[i][j].first, nj = pre[i][j].second;
i = ni, j = nj;
}
reverse((S).begin(), (S).end());
S.pop_back();
if ((int)(S).size() < len)
len = (int)(S).size(), ans = S;
else if ((int)(S).size() == len)
ans = min(ans, S);
}
void dfs(int c, int k) {
if (k > K) return;
if (c == (int)(has).size()) {
solve();
return;
}
dfs(c + 1, k);
ok.push_back(has[c]);
dfs(c + 1, k + 1);
ok.pop_back();
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (s[i][j] == 'S')
sx = i, sy = j;
else if (s[i][j] == 'T')
ex = i, ey = j;
else
has.push_back(s[i][j]);
}
sort((has).begin(), (has).end());
has.erase(unique((has).begin(), (has).end()), has.end());
dfs(0, 0);
if (!fd)
puts("-1");
else
printf("%s\n", ans.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, can[256], fx, fy, sx, sy;
int d[] = {0, 1, 1, 0, -1, 0, 0, -1};
int a[70][70], ans = (1 << 30);
char Map[70][70];
bool u[70][70];
queue<int> qx, qy, Qx[2], Qy[2];
string strans, str;
bool check(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
void path(int steps) {
str = "";
steps--;
int x, y, dx, dy, mn;
char want;
Qx[steps & 1].push(sx);
Qy[steps & 1].push(sy);
for (; steps >= 0; steps--) {
queue<int> &qX = Qx[steps & 1], &qY = Qy[steps & 1],
&nx = Qx[(steps + 1) & 1], &ny = Qy[(steps + 1) & 1];
want = 'z' + 1;
memset(u, 0, sizeof u);
while (!qX.empty()) {
x = qX.front();
y = qY.front();
qX.pop();
qY.pop();
for (int i = 0; i < 8; i += 2) {
dx = x + d[i];
dy = y + d[i + 1];
if (!check(dx, dy)) continue;
if (a[dx][dy] != a[x][y] - 1) continue;
if (Map[dx][dy] < want) {
while (!nx.empty()) nx.pop(), ny.pop();
want = Map[dx][dy];
}
if (Map[dx][dy] == want && !u[dx][dy])
nx.push(dx), ny.push(dy), u[dx][dy] = 1;
}
}
if (want == 'T') break;
str.push_back(want);
}
}
void solve() {
int x, y, dx, dy;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = (1 << 30);
}
}
qx.push(fx);
qy.push(fy);
a[fx][fy] = 0;
while (!qx.empty()) {
x = qx.front();
y = qy.front();
qx.pop();
qy.pop();
for (int i = 0; i < 8; i += 2) {
dx = x + d[i];
dy = y + d[i + 1];
if (check(dx, dy) && a[dx][dy] > a[x][y] + 1 && can[Map[dx][dy]]) {
a[dx][dy] = a[x][y] + 1;
qx.push(dx);
qy.push(dy);
}
}
}
if (a[sx][sy] == (1 << 30)) return;
if (a[sx][sy] < ans) {
ans = a[sx][sy];
path(a[sx][sy]);
strans = str;
} else if (a[sx][sy] == ans) {
path(a[sx][sy]);
if (str < strans) strans = str;
}
}
void rec(int d, int i = 0) {
if (d == k) {
solve();
return;
}
for (; i < 27; i++) {
can['a' + i] = 1;
rec(d + 1, i + 1);
can['a' + i] = 0;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%s", Map[i]);
for (int j = 0; j < m; j++) {
if (Map[i][j] == 'S') sx = i, sy = j;
if (Map[i][j] == 'T') fx = i, fy = j;
}
}
can['S'] = can['T'] = 1;
rec(0);
if (ans < (1 << 30))
printf("%s\n", strans.c_str());
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T res) {
cout << res << endl;
exit(0);
}
string a[55];
int n, m, k, st, fn;
bool allowed[26];
int way[55][55];
int dist[55][55];
int dr[] = {+1, 0, -1, 0};
int dc[] = {0, +1, 0, -1};
bool inBounds(int r, int c) { return (0 <= r && r < n && 0 <= c && c < m); }
bool Check(int r, int c) {
return inBounds(r, c) &&
(a[r][c] == 'S' || a[r][c] == 'T' || allowed[a[r][c] - 'a']);
}
string getWay(char c1, char c2, char c3, char c4) {
memset(dist, -1, sizeof(dist));
dist[fn / m][fn % m] = 0;
queue<int> q;
q.push(fn);
while (!q.empty()) {
int r = q.front() / m;
int c = q.front() % m;
q.pop();
int nr, nc;
for (int p = (0), _b(4); p < _b; p++)
if (Check(nr = r + dr[p], nc = c + dc[p])) {
if (dist[nr][nc] != -1) continue;
dist[nr][nc] = dist[r][c] + 1;
q.push(nr * m + nc);
}
}
if (dist[st / m][st % m] == -1) return "-1";
vector<int> v;
v.push_back(st);
string res = "";
for (int i = (1), _b(dist[st / m][st % m]); i < _b; i++) {
int nr, nc;
int mm = 26;
for (int j = (0), _b((int)(v).size()); j < _b; j++)
for (int p = (0), _b(4); p < _b; p++)
if (Check(nr = v[j] / m + dr[p], nc = v[j] % m + dc[p]))
if (dist[nr][nc] == dist[st / m][st % m] - i)
mm = min(mm, a[nr][nc] - 'a');
res += (mm + 'a');
vector<int> add;
for (int j = (0), _b((int)(v).size()); j < _b; j++)
for (int p = (0), _b(4); p < _b; p++)
if (Check(nr = v[j] / m + dr[p], nc = v[j] % m + dc[p]))
if (dist[nr][nc] == dist[st / m][st % m] - i)
if (a[nr][nc] - 'a' == mm) add.push_back(nr * m + nc);
v.clear();
for (int j = (0), _b((int)(add).size()); j < _b; j++) v.push_back(add[j]);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
return res;
}
int main() {
cin >> n >> m >> k;
for (int i = (0), _b(n); i < _b; i++) cin >> a[i];
for (int i = (0), _b(n); i < _b; i++)
for (int j = (0), _b(m); j < _b; j++) {
if (a[i][j] == 'S') st = i * m + j;
if (a[i][j] == 'T') fn = i * m + j;
}
string res = "-1";
for (int c1 = (0), _b(26); c1 < _b; c1++)
for (int c2 = (c1), _b(26); c2 < _b; c2++)
for (int c3 = (c2), _b(26); c3 < _b; c3++)
for (int c4 = (c3), _b(26); c4 < _b; c4++) {
if (k > 0) allowed[c1] = true;
if (k > 1) allowed[c2] = true;
if (k > 2) allowed[c3] = true;
if (k > 3) allowed[c4] = true;
string curr = getWay(c1, c2, c3, c4);
if (curr != "-1")
if (res == "-1" || (int)(res).size() > (int)(curr).size() ||
((int)(res).size() == (int)(curr).size() && res > curr))
res = curr;
allowed[c1] = allowed[c2] = allowed[c3] = allowed[c4] = false;
}
out(res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, msk;
string s;
node(int x1, int x2, int x3, string x4) { x = x1, y = x2, msk = x3, s = x4; }
bool operator<(const node &b) const {
if (s.size() != b.s.size()) return s.size() > b.s.size();
return s > b.s;
}
};
int gx[5] = {0, 1, 0, -1, 0}, gy[5] = {0, 0, 1, 0, -1};
char s[51][51];
set<int> st[51][51];
int las[51][51];
int count(int x) {
int ans = 0;
while (x) ans += x & 1, x >>= 1;
return ans;
}
signed main() {
int x = 0, y = 0;
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) cin >> s[i] + 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == 'S') x = i, y = j;
priority_queue<node> q;
q.push(node(x, y, 0, ""));
while (!q.empty()) {
node u = q.top();
q.pop();
for (int i = 1; i <= 4; i++) {
int tox = u.x + gx[i];
int toy = u.y + gy[i];
if (tox > n || toy > m || tox <= 0 || toy <= 0) continue;
if (s[tox][toy] == 'T') {
cout << u.s;
return 0;
}
int mk = u.msk | (1 << (s[tox][toy] - 'a'));
if (count(mk) > k) continue;
if (las[tox][toy] && ((las[tox][toy] & mk) == las[tox][toy])) continue;
las[tox][toy] = mk;
if (st[tox][toy].count(mk)) continue;
st[tox][toy].insert(mk);
string tmp = u.s;
q.push(node(tox, toy, mk, u.s + s[tox][toy]));
}
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 1000000000;
const int Maxn = 50;
const int Maxl = 26;
const int Maxd = 4;
const int dy[Maxd] = {1, 0, -1, 0};
const int dx[Maxd] = {0, 1, 0, -1};
int n, m, k;
char B[Maxn][Maxn];
int sx, sy, ex, ey;
int has[Maxl];
int dist[Maxn][Maxn];
pair<int, int> p[Maxn][Maxn];
string s, res;
bool sol;
void BFS() {
fill((int *)dist, (int *)dist + Maxn * Maxn, Inf);
pair<int, int> v = make_pair(ex, ey);
dist[v.first][v.second] = 0;
vector<pair<int, int> > seq, buck[Maxl];
seq.push_back(v);
for (int i = 0; !seq.empty(); i++) {
for (int j = 0; j < seq.size(); j++) {
v = seq[j];
for (int d = 0; d < Maxd; d++) {
int ni = v.first + dy[d], nj = v.second + dx[d];
if (0 <= ni && ni < n && 0 <= nj && nj < m && i + 1 < dist[ni][nj] &&
(B[ni][nj] == 'S' || has[B[ni][nj] - 'a'])) {
dist[ni][nj] = i + 1;
p[ni][nj] = make_pair(v.first, v.second);
if (B[ni][nj] == 'S')
return;
else
buck[B[ni][nj] - 'a'].push_back(make_pair(ni, nj));
}
}
}
seq.clear();
for (int j = 0; j < Maxl; j++) {
for (int l = 0; l < buck[j].size(); l++) seq.push_back(buck[j][l]);
buck[j].clear();
}
}
}
void getPath(string &s) {
s = "";
pair<int, int> v = p[sx][sy];
while (v.first != ex || v.second != ey) {
s += B[v.first][v.second];
v = p[v.first][v.second];
}
}
void Search(int v, int from) {
if (v == k) {
BFS();
if (dist[sx][sy] == Inf) return;
getPath(s);
if (!sol || s.length() < res.length() ||
s.length() == res.length() && s < res)
res = s;
sol = true;
} else
for (int i = from; i < Maxl; i++) {
has[i] = true;
Search(v + 1, i + 1);
has[i] = false;
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf(" %c", &B[i][j]);
if (B[i][j] == 'S') {
sx = i;
sy = j;
} else if (B[i][j] == 'T') {
ex = i;
ey = j;
B[i][j] = 'a';
}
}
Search(0, 0);
if (!sol)
printf("-1\n");
else
printf("%s\n", res.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char field[50][50];
bool used[50][50];
int n, m, k;
int counts[26];
int cur_set;
set<string> min_ways;
int min_len = INT_MAX;
int start_x, start_y, end_x, end_y;
vector<char> alpha(0);
bool comp(pair<int, int> a, pair<int, int> b) {
if (field[a.first][a.second] == 'T') return true;
if (field[b.first][b.second] == 'T') return false;
return field[a.first][a.second] < field[b.first][b.second];
}
vector<pair<int, int>> find_near(int from_y, int from_x,
const set<char> &from_set) {
vector<pair<int, int>> near(0);
if (from_y > 0 && !used[from_y - 1][from_x] &&
from_set.find(field[from_y - 1][from_x]) != from_set.end())
near.push_back(make_pair(from_y - 1, from_x));
if (from_y < n - 1 && !used[from_y + 1][from_x] &&
from_set.find(field[from_y + 1][from_x]) != from_set.end())
near.push_back(make_pair(from_y + 1, from_x));
if (from_x > 0 && !used[from_y][from_x - 1] &&
from_set.find(field[from_y][from_x - 1]) != from_set.end())
near.push_back(make_pair(from_y, from_x - 1));
if (from_x < m - 1 && !used[from_y][from_x + 1] &&
from_set.find(field[from_y][from_x + 1]) != from_set.end())
near.push_back(make_pair(from_y, from_x + 1));
sort(near.begin(), near.end(), comp);
return near;
}
set<char> find_set_near(int from_y, int from_x) {
set<char> near = set<char>();
if (from_y > 0 && !used[from_y - 1][from_x])
near.insert(field[from_y - 1][from_x]);
if (from_y < n - 1 && !used[from_y + 1][from_x])
near.insert(field[from_y + 1][from_x]);
if (from_x > 0 && !used[from_y][from_x - 1])
near.insert(field[from_y][from_x - 1]);
if (from_x < m - 1 && !used[from_y][from_x + 1])
near.insert(field[from_y][from_x + 1]);
near.erase('T');
near.erase('S');
return near;
}
set<char> find_second_near_set(int from_y, int from_x, set<char> ¬_from) {
bool l2, l1, r1, r2, u1, u2, d1, d2;
l2 = from_x - 2 >= 0;
l1 = from_x > 0;
r1 = from_x + 2 < m;
r2 = from_x + 1 < m;
u2 = from_y - 2 >= 0;
u1 = from_y > 0;
d1 = from_y + 1 < n;
d2 = from_y + 2 < n;
int yu2 = from_y - 2;
int yu1 = from_y - 1;
int yd1 = from_y + 1;
int yd2 = from_y + 2;
int xl2 = from_x - 2;
int xl1 = from_x - 1;
int xr1 = from_x + 1;
int xr2 = from_x + 2;
set<char> ret = set<char>();
if (l1 && u2) ret.insert(field[yu2][xl1]);
if (u2) ret.insert(field[yu2][from_x]);
if (u2 && r1) ret.insert(field[yu2][xr1]);
if (r2) {
if (u1) ret.insert(field[yu1][xr2]);
ret.insert(field[from_y][xr2]);
if (d1) ret.insert(field[yd1][xr2]);
}
if (d2) {
if (r1) ret.insert(field[yd2][xr1]);
ret.insert(field[yd2][from_x]);
if (l1) ret.insert(field[yd2][xl1]);
}
if (l2) {
if (d1) ret.insert(field[yd1][xl2]);
ret.insert(field[from_y][xl2]);
if (u1) ret.insert(field[yu1][xl2]);
}
for (set<char>::iterator i = not_from.begin(); i != not_from.end(); i++)
ret.erase(*i);
return ret;
}
void read() {
set<char> set_alpha = set<char>();
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> field[i][j];
if (field[i][j] == 'S') {
start_y = i;
start_x = j;
} else if (field[i][j] == 'T') {
end_y = i;
end_x = j;
} else
set_alpha.insert(field[i][j]);
}
for (set<char>::iterator i = set_alpha.begin(); i != set_alpha.end(); i++)
alpha.push_back(*i);
}
struct cell {
pair<int, int> pos;
string s;
};
struct comp2 {
bool operator()(const cell &a, const cell &b) {
if (a.s.size() != b.s.size())
return a.s.size() < b.s.size();
else
return a.s < b.s;
}
};
set<set<char>> last_sets;
bool wave(set<char> &cur_set) {
if (last_sets.find(cur_set) != last_sets.end())
return false;
else
last_sets.insert(cur_set);
memset(used, false, 2500);
used[start_y][start_x] = true;
cur_set.insert('T');
multiset<cell, comp2> myque;
cell tmp;
tmp.pos = make_pair(start_y, start_x);
tmp.s = string("");
myque.insert(tmp);
while (!myque.empty()) {
cell cur_cell = *myque.begin();
myque.erase(myque.begin());
if (cur_cell.s.length() > min_len) break;
vector<pair<int, int>> near =
find_near(cur_cell.pos.first, cur_cell.pos.second, cur_set);
for (vector<pair<int, int>>::iterator i = near.begin(); i != near.end();
i++) {
if (field[i->first][i->second] == 'T') {
if (cur_cell.s.length() < min_len) {
min_ways.clear();
min_len = cur_cell.s.length();
}
min_ways.insert(cur_cell.s);
break;
}
used[i->first][i->second] = true;
cell tmp = cur_cell;
tmp.pos = *i;
tmp.s.push_back(field[i->first][i->second]);
myque.insert(tmp);
}
}
cur_set.erase('T');
return false;
}
int main() {
read();
string s("");
set<char> start_set = find_set_near(start_y, start_x);
set<char> end_set = find_set_near(end_y, end_x);
int l = alpha.size();
set<char> cur_set = set<char>();
if (!l)
wave(cur_set);
else {
for (set<char>::iterator a = start_set.begin(); a != start_set.end(); a++) {
cur_set.insert(*a);
if (cur_set.size() == k || l < k && cur_set.size() == l)
wave(cur_set);
else {
for (set<char>::iterator b = end_set.begin(); b != end_set.end(); b++) {
cur_set.insert(*b);
if (cur_set.size() == k || l < k && cur_set.size() == l)
wave(cur_set);
else {
for (int i = 0; i < l; i++) {
if (cur_set.end() != cur_set.find(alpha[i])) continue;
cur_set.insert(alpha[i]);
if (cur_set.size() == k || l < k && cur_set.size() == l)
wave(cur_set);
else {
for (int j = i + 1; j < l; j++) {
if (cur_set.end() != cur_set.find(alpha[j])) continue;
cur_set.insert(alpha[j]);
if ((*a) == (*b) && cur_set.size() < k) {
set<char> second_set =
find_second_near_set(start_y, start_x, cur_set);
if (!second_set.size())
wave(cur_set);
else {
for (set<char>::iterator p = second_set.begin();
p != second_set.end(); p++) {
cur_set.insert(*p);
wave(cur_set);
cur_set.erase(*p);
}
}
} else
wave(cur_set);
cur_set.erase(alpha[j]);
}
}
cur_set.erase(alpha[i]);
}
}
cur_set.erase(*b);
}
}
cur_set.erase(*a);
}
}
label_end:
if (min_len == INT_MAX)
cout << "-1";
else
cout << (*min_ways.begin());
}
|
#include <bits/stdc++.h>
using namespace std;
int R, C, K, Tail;
int Board[60][60], Road[60][60], Best[60][60], Oki[60][60];
int Allow[100000][5];
int Last[60][60];
char Now[5];
int Res;
int Check[30];
char Ans[10000];
int QR[10000], QC[10000];
void pre_process(char now, int left) {
if (now > 'z') {
if (left == 0) {
int i;
for (i = 0; i < (int)(K); i++) Allow[Tail][i] = (int)(Now[i] - 'a');
Tail++;
}
return;
}
pre_process(now + 1, left);
if (left > 0) {
Now[left - 1] = now;
pre_process(now + 1, left - 1);
}
}
bool isValid(int r, int c) {
return 0 <= r && r < R && 0 <= c && c < C && Road[r][c];
}
int main() {
int i, j, k, r, c;
int sr, sc, er, ec;
char a;
int dr[4] = {-1, 0, 1, 0};
int dc[4] = {0, 1, 0, -1};
int tt, et;
scanf("%d%d%d", &R, &C, &K);
for (i = 0; i < (int)(R); i++) {
for (j = 0; j < (int)(C); j++) {
scanf("%c", &a);
if (!('a' <= a && a <= 'z') && a != 'S' && a != 'T') {
j--;
continue;
}
if ('a' <= a && a <= 'z')
Board[i][j] = a - 'a';
else if (a == 'S')
Board[i][j] = -1, sr = i, sc = j;
else
Board[i][j] = -2, er = i, ec = j;
}
}
Tail = 0;
pre_process('a', K);
Res = -1;
for (i = 0; i < (int)(Tail); i++) {
for (j = 0; j < (int)(26); j++) Check[j] = 0;
for (j = 0; j < (int)(K); j++) Check[Allow[i][j]] = 1;
for (r = 0; r < (int)(R); r++)
for (c = 0; c < (int)(C); c++) {
if (Board[r][c] >= 0)
Road[r][c] = Check[Board[r][c]];
else
Road[r][c] = 1;
Best[r][c] = -1;
Oki[r][c] = 0;
Last[r][c] = 0;
}
tt = 1;
QR[0] = sr, QC[0] = sc;
Best[sr][sc] = 0;
for (j = 0; j < (int)(tt); j++) {
r = QR[j], c = QC[j];
for (k = 0; k < (int)(4); k++)
if (isValid(r + dr[k], c + dc[k]) && Best[r + dr[k]][c + dc[k]] == -1) {
Best[r + dr[k]][c + dc[k]] = Best[r][c] + 1;
QR[tt] = r + dr[k], QC[tt] = c + dc[k];
tt++;
}
}
if (Best[er][ec] == -1 || (Res != -1 && Best[er][ec] > Res)) continue;
bool update = false;
if (Res == -1 || Best[er][ec] < Res) update = true;
Res = Best[er][ec];
Ans[Res - 1] = Ans[Res] = 0;
tt = 1;
QR[0] = er, QC[0] = ec;
Oki[er][ec] = 1;
for (j = 0; j < (int)(tt); j++) {
r = QR[j], c = QC[j];
for (k = 0; k < (int)(4); k++)
if (isValid(r + dr[k], c + dc[k]) &&
Best[r + dr[k]][c + dc[k]] == Best[r][c] - 1 &&
!Oki[r + dr[k]][c + dc[k]]) {
Oki[r + dr[k]][c + dc[k]] = 1;
QR[tt] = r + dr[k], QC[tt] = c + dc[k];
tt++;
}
}
int cur = 0, tt = 1, move = 0;
QR[0] = sr, QC[0] = sc;
Best[sr][sc] = 0;
while (cur < Res - 1) {
et = tt;
int best = -1;
for (j = move; j < et; j++) {
r = QR[j], c = QC[j];
for (k = 0; k < (int)(4); k++)
if (isValid(r + dr[k], c + dc[k]) && Oki[r + dr[k]][c + dc[k]] &&
Best[r + dr[k]][c + dc[k]] == cur + 1) {
if (best == -1 || best > Board[r + dr[k]][c + dc[k]]) {
best = Board[r + dr[k]][c + dc[k]];
}
}
}
if (!update && (char)(best + 'a') > Ans[cur]) break;
if (!update && (char)(best + 'a') < Ans[cur]) update = true;
Ans[cur] = (char)(best + 'a');
cur++;
for (j = move; j < et; j++) {
r = QR[j], c = QC[j];
for (k = 0; k < (int)(4); k++)
if (isValid(r + dr[k], c + dc[k]) && Oki[r + dr[k]][c + dc[k]] &&
Best[r + dr[k]][c + dc[k]] == cur &&
!Last[r + dr[k]][c + dc[k]]) {
if (best == Board[r + dr[k]][c + dc[k]]) {
Last[r + dr[k]][c + dc[k]] = 1;
QR[tt] = r + dr[k], QC[tt] = c + dc[k];
tt++;
}
}
}
move = et;
}
}
if (Res == -1)
printf("%d\n", Res);
else
printf("%s\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
queue<pair<int, int> > q;
string s, jwb;
pair<int, int> u, aw, ak;
int r, c, bts, a, h, mi, ni, nj, ui, uj;
char sc[55][55];
int boleh[27];
string kjg[55][55];
int ari[4] = {-1, 0, 1, 0};
int arj[4] = {0, 1, 0, -1};
int main() {
scanf("%d%d%d", &r, &c, &bts);
for (int i = 0; i < r; i++) {
scanf("%s", sc[i]);
for (int j = 0; j < c; j++) {
if (sc[i][j] == 'S') {
aw = make_pair(i, j);
}
if (sc[i][j] == 'T') {
ak = make_pair(i, j);
}
}
}
for (int i = 0; i < 26; i++) {
boleh[i] = 1;
}
for (int i = 0; i < bts; i++) {
boleh[i] = 0;
}
jwb = "";
mi = 2123123123;
do {
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
kjg[i][j] = "";
}
}
q.push(aw);
while (!q.empty()) {
ui = q.front().first;
uj = q.front().second;
q.pop();
for (int k = 0; k < 4; k++) {
ni = ui + ari[k];
nj = uj + arj[k];
if ((0 <= ni) && (ni < r) && (0 <= nj) && (nj < c) &&
(sc[ni][nj] != 'S')) {
if (sc[ni][nj] == 'T') {
if (kjg[ni][nj].size() == 0) {
kjg[ni][nj] = kjg[ui][uj] + sc[ni][nj];
q.push(make_pair(ni, nj));
} else if ((kjg[ni][nj].size() == kjg[ui][uj].size() + 1) &&
(kjg[ni][nj] > kjg[ui][uj] + sc[ni][nj])) {
kjg[ni][nj] = kjg[ui][uj] + sc[ni][nj];
}
} else if (boleh[sc[ni][nj] - 'a'] == 0) {
if (kjg[ni][nj].size() == 0) {
kjg[ni][nj] = kjg[ui][uj] + sc[ni][nj];
q.push(make_pair(ni, nj));
} else if ((kjg[ni][nj].size() == kjg[ui][uj].size() + 1) &&
(kjg[ni][nj] > kjg[ui][uj] + sc[ni][nj])) {
kjg[ni][nj] = kjg[ui][uj] + sc[ni][nj];
}
}
}
}
}
if ((int)kjg[ak.first][ak.second].size() > 0) {
kjg[ak.first][ak.second].erase(kjg[ak.first][ak.second].size() - 1, 1);
if ((int)kjg[ak.first][ak.second].size() < mi) {
mi = kjg[ak.first][ak.second].size();
jwb = kjg[ak.first][ak.second];
} else if ((int)kjg[ak.first][ak.second].size() == mi) {
jwb = min(jwb, kjg[ak.first][ak.second]);
}
}
} while (next_permutation(boleh, boleh + 26));
if (mi == 2123123123) {
cout << -1 << endl;
} else {
cout << jwb << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char tbl[60][60];
int n, m, k, sx, sy, gx, gy;
void input() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", tbl[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (tbl[i][j] == 'S') {
sx = i;
sy = j;
} else if (tbl[i][j] == 'T') {
gx = i;
gy = j;
}
}
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
bool ok[130];
int dis[60][60], vis[60][60], fx[60][60], fy[60][60];
inline bool valid(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && ok[(int)tbl[x][y]];
}
bool cmp(int x1, int y1, int x2, int y2) {
if (tbl[x1][y1] != tbl[x2][y2]) return tbl[x1][y1] < tbl[x2][y2];
if (x1 == y1 && x2 == y2) return 0;
return cmp(fx[x1][y1], fy[x1][y1], fx[x2][y2], fy[x2][y2]);
}
string go(int a, int b, int c, int d) {
static int tmt = 0;
tmt++;
ok[a] = ok[b] = ok[c] = ok[d] = 1;
queue<int> q;
vis[gx][gy] = tmt;
dis[gx][gy] = 0;
q.push(gx);
q.push(gy);
while (!q.empty()) {
int x = q.front();
q.pop();
int y = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (!valid(nx, ny)) continue;
if (vis[nx][ny] != tmt) {
vis[nx][ny] = tmt;
dis[nx][ny] = dis[x][y] + 1;
fx[nx][ny] = x;
fy[nx][ny] = y;
q.push(nx);
q.push(ny);
} else if (dis[nx][ny] == dis[x][y] + 1) {
if (cmp(x, y, fx[nx][ny], fy[nx][ny])) {
fx[nx][ny] = x;
fy[nx][ny] = y;
}
}
}
}
ok[a] = ok[b] = ok[c] = ok[d] = 0;
if (vis[sx][sy] != tmt)
return "!";
else {
string ret;
int x = fx[sx][sy], y = fy[sx][sy], xx, yy;
while (x != gx || y != gy) {
ret += tbl[x][y];
xx = fx[x][y];
yy = fy[x][y];
x = xx;
y = yy;
}
return ret;
}
}
int len = 10000;
string ans;
void chk(int a, int b, int c, int d) {
string now = go(a, b, c, d);
if (now == "!") return;
if ((int)now.size() < len || ((int)now.size() == len && now < ans)) {
ans = now;
len = now.size();
}
}
void solve() {
for (int a = 'a'; a <= 'z'; a++)
if (k == 1)
chk(a, 0, 0, 0);
else
for (int b = a + 1; b <= 'z'; b++)
if (k == 2)
chk(a, b, 0, 0);
else
for (int c = b + 1; c <= 'z'; c++)
if (k == 3)
chk(a, b, c, 0);
else
for (int d = c + 1; d <= 'z'; d++) chk(a, b, c, d);
if (len == 10000)
puts("-1");
else
printf("%s\n", ans.c_str());
}
int main() {
ok[(int)'S'] = ok[(int)'T'] = 1;
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[55][55];
int d[55][55];
char res[55 * 55], c[55 * 55];
int u[256];
int nr, nc;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int n, m;
int ch(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
struct pt {
int x;
int y;
friend int operator<(pt a, pt b) {
if (a.x != b.x) {
return a.x < b.x;
}
return a.y < b.y;
}
};
set<pt> ss;
pt p, p1, p2;
queue<pt> q;
pt b[55 * 55 * 5], bb[55 * 55 * 5];
int nb, nbb;
int cmp(char a[55 * 55], char b[55 * 55]) {
int i;
for (i = 0; a[i] && b[i]; i++) {
if (a[i] != b[i]) {
return a[i] < b[i];
}
}
return 0;
}
int i, j, k, x, y, z, t, t1, mx, c1, c2, c3, c4, bx, by, ex, ey, r, l;
int mn;
int main() {
scanf("%d%d%d", &n, &m, &mx);
for (i = 0; i < n; i++) {
scanf("%s", &a[i]);
for (j = 0; j < m; j++) {
if (a[i][j] == 'S') {
bx = i;
by = j;
}
if (a[i][j] == 'T') {
ex = i;
ey = j;
}
}
}
u['T'] = 1;
u['S'] = 1;
for (c1 = 'a'; c1 <= 'z'; c1++) {
for (c2 = c1; c2 <= 'z'; c2++) {
for (c3 = c2; c3 <= 'z'; c3++) {
for (c4 = c3; c4 <= 'z'; c4++) {
for (i = 'a'; i <= 'z'; i++) {
u[i] = 0;
}
if (mx >= 1) {
u[c1] = 1;
}
if (mx >= 2) {
u[c2] = 1;
}
if (mx >= 3) {
u[c3] = 1;
}
if (mx >= 4) {
u[c4] = 1;
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
d[i][j] = -1;
}
}
while (!q.empty()) q.pop();
p.x = ex;
p.y = ey;
d[p.x][p.y] = 0;
q.push(p);
while (!q.empty()) {
p = q.front();
q.pop();
for (i = 0; i < 4; i++) {
x = p.x + dx[i];
y = p.y + dy[i];
if (ch(x, y) && u[a[x][y]] == 1 && d[x][y] == -1) {
d[x][y] = d[p.x][p.y] + 1;
p1.x = x;
p1.y = y;
q.push(p1);
}
}
}
if (d[bx][by] == -1 || (d[bx][by] > nr && nr > 0)) {
continue;
}
p.x = bx;
p.y = by;
nb = 0;
b[nb++] = p;
nc = d[bx][by];
for (l = 0; l < nc; l++) {
nbb = 0;
mn = 1000000;
ss.clear();
for (i = 0; i < nb; i++) {
for (j = 0; j < 4; j++) {
x = b[i].x + dx[j];
y = b[i].y + dy[j];
if (ch(x, y) && d[x][y] == nc - l - 1) {
if (a[x][y] < mn) {
mn = a[x][y];
}
}
}
}
for (i = 0; i < nb; i++) {
for (j = 0; j < 4; j++) {
x = b[i].x + dx[j];
y = b[i].y + dy[j];
if (ch(x, y) && d[x][y] == nc - l - 1 && a[x][y] == mn) {
p1.x = x;
p1.y = y;
if (ss.find(p1) == ss.end()) {
bb[nbb++] = p1;
ss.insert(p1);
}
}
}
}
for (i = 0; i < nbb; i++) {
b[i] = bb[i];
}
nb = nbb;
c[l] = mn;
}
c[nc] = 0;
if (nc < nr || nr == 0 || cmp(c, res)) {
nr = nc;
for (i = 0; i < nc; i++) {
res[i] = c[i];
}
res[nr] = 0;
}
if (mx >= 4) {
u[c4] = 0;
}
}
if (mx >= 3) {
u[c3] = 0;
}
}
if (mx >= 2) {
u[c2] = 0;
}
}
u[c1] = 0;
}
if (nr == 0) {
printf("-1\n");
return 0;
} else {
res[nr - 1] = 0;
printf("%s\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int SX, SY, TX, TY;
int N, M, K;
char V[52][52];
vector<vector<int> > C;
vector<int> cur;
void gen(int sv, int how) {
if (sv >= 26 && cur.size() == K) C.push_back(cur);
if (sv >= 26 || how < 0) return;
gen(sv + 1, how);
if (how > 0) {
cur.push_back(sv);
gen(sv + 1, how - 1);
cur.pop_back();
}
}
int bestl = (int)1E9;
string best;
bool can[300];
int LEV[50][50];
deque<int> QX, QY;
string dp[50][50];
string wrd;
vector<int> PX, PY;
vector<int> _PX, _PY;
int u1[50][50], u1s = 0;
string dfs(int x, int y) {
PX.clear();
PY.clear();
wrd = "";
PX.push_back(x);
PY.push_back(y);
while (1) {
++u1s;
if (PX[0] == TX && PY[0] == TY) return wrd;
_PX.clear();
_PY.clear();
char USE = 'z' + 1;
for (int i = 0; i < PX.size(); ++i) {
x = PX[i];
y = PY[i];
if (x - 1 >= 0 && can[V[x - 1][y]] && LEV[x - 1][y] == LEV[x][y] - 1)
USE = min(USE, V[x - 1][y]);
if (y - 1 >= 0 && can[V[x][y - 1]] && LEV[x][y - 1] == LEV[x][y] - 1)
USE = min(USE, V[x][y - 1]);
if (x + 1 < N && can[V[x + 1][y]] && LEV[x + 1][y] == LEV[x][y] - 1)
USE = min(USE, V[x + 1][y]);
if (y + 1 < M && can[V[x][y + 1]] && LEV[x][y + 1] == LEV[x][y] - 1)
USE = min(USE, V[x][y + 1]);
}
wrd += USE;
for (int i = 0; i < PX.size(); ++i) {
x = PX[i];
y = PY[i];
if (x - 1 >= 0 && can[V[x - 1][y]] && LEV[x - 1][y] == LEV[x][y] - 1 &&
USE == V[x - 1][y]) {
if (u1[x - 1][y] != u1s) {
_PX.push_back(x - 1);
_PY.push_back(y);
u1[x - 1][y] = u1s;
}
}
if (y - 1 >= 0 && can[V[x][y - 1]] && LEV[x][y - 1] == LEV[x][y] - 1 &&
USE == V[x][y - 1]) {
if (u1[x][y - 1] != u1s) {
_PX.push_back(x);
_PY.push_back(y - 1);
u1[x][y - 1] = u1s;
}
}
if (x + 1 < N && can[V[x + 1][y]] && LEV[x + 1][y] == LEV[x][y] - 1 &&
USE == V[x + 1][y]) {
if (u1[x + 1][y] != u1s) {
_PX.push_back(x + 1);
_PY.push_back(y);
u1[x + 1][y] = u1s;
}
}
if (y + 1 < M && can[V[x][y + 1]] && LEV[x][y + 1] == LEV[x][y] - 1 &&
USE == V[x][y + 1]) {
if (u1[x][y + 1] != u1s) {
_PX.push_back(x);
_PY.push_back(y + 1);
u1[x][y + 1] = u1s;
}
}
}
PX = _PX;
PY = _PY;
}
}
string BFS(vector<int> U) {
int i, j;
for (i = 0; i < N; ++i)
for (j = 0; j < M; ++j) dp[i][j].clear();
memset(LEV, -1, sizeof LEV);
QX.clear();
QY.clear();
for (i = 0; i < U.size(); ++i) can[U[i] + 'a'] = true;
can['S'] = can['T'] = true;
LEV[TX][TY] = 1;
QX.push_back(TX);
QY.push_back(TY);
while (!QX.empty()) {
int x = QX[0], y = QY[0];
QX.pop_front();
QY.pop_front();
if (x - 1 >= 0 && can[V[x - 1][y]] && LEV[x - 1][y] == -1) {
LEV[x - 1][y] = LEV[x][y] + 1;
QX.push_back(x - 1);
QY.push_back(y);
}
if (y - 1 >= 0 && can[V[x][y - 1]] && LEV[x][y - 1] == -1) {
LEV[x][y - 1] = LEV[x][y] + 1;
QX.push_back(x);
QY.push_back(y - 1);
}
if (x + 1 < N && can[V[x + 1][y]] && LEV[x + 1][y] == -1) {
LEV[x + 1][y] = LEV[x][y] + 1;
QX.push_back(x + 1);
QY.push_back(y);
}
if (y + 1 < M && can[V[x][y + 1]] && LEV[x][y + 1] == -1) {
LEV[x][y + 1] = LEV[x][y] + 1;
QX.push_back(x);
QY.push_back(y + 1);
}
if (LEV[SX][SY] != -1) break;
}
string ret = "NO";
if (LEV[SX][SY] - LEV[TX][TY] - 1 <= bestl)
if (LEV[SX][SY] != -1) {
ret = dfs(SX, SY);
ret = ret.substr(0, (int)ret.size() - 1);
}
for (i = 0; i < U.size(); ++i) can[U[i] + 'a'] = false;
can['S'] = can['T'] = false;
return ret;
}
bool IN[300];
int main() {
int i, j, k, l, B = 0;
scanf("%d%d%d", &N, &M, &K);
for (i = 0; i < N; ++i) scanf("%s", &V[i]);
for (i = 0; i < N; ++i)
for (j = 0; j < M; ++j) {
if (V[i][j] == 'S') {
SX = i;
SY = j;
} else if (V[i][j] == 'T') {
TX = i;
TY = j;
} else {
if (!IN[V[i][j]]) ++B;
IN[V[i][j]] = 1;
}
}
K = min(K, B);
gen(0, K);
for (i = 0; i < C.size(); ++i) {
bool OK = true;
for (j = 0; j < C[i].size(); ++j)
if (!IN['a' + C[i][j]]) {
OK = false;
break;
}
if (!OK) continue;
string T = BFS(C[i]);
if (T == "NO") continue;
if (T.size() < bestl || (T.size() == bestl && T < best)) {
best = T;
bestl = best.size();
}
}
if (bestl > 1000000)
cout << "-1\n";
else
cout << best << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626433832795;
const int N = 100;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
int n, m, k;
char a[N][N];
inline int sign(int a) {
if (a == 0) return 0;
return ((a < 0) ? (-1) : (1));
}
int szchrs;
char chrs[N * N];
pair<int, int> st, fn, sc;
char tp[N];
bool isGood[300];
pair<int, int> bs, bt;
inline bool good(const pair<int, int>& a) {
return bs.first <= a.first && a.first < bt.first && bs.second <= a.second &&
a.second < bt.second;
}
int cu;
int used[N][N];
int lvl[N][N], lvlT[N][N];
void updateAns(string& ans) {
string res = "";
vector<pair<int, int> > cur;
cur.push_back(sc);
res.push_back(tp[0]);
cu++;
used[sc.first][sc.second] = cu;
lvl[sc.first][sc.second] = 0;
queue<pair<int, int> > q;
q.push(sc);
while (!q.empty()) {
pair<int, int> v = q.front();
q.pop();
for (int i = 0; i < int(4); ++i) {
pair<int, int> u(v.first + dx[i], v.second + dy[i]);
if (good(u) && isGood[a[u.first][u.second]] &&
used[u.first][u.second] < cu) {
used[u.first][u.second] = cu;
lvl[u.first][u.second] = lvl[v.first][v.second] + 1;
q.push(u);
}
}
}
if (used[fn.first][fn.second] < cu) return;
cu++;
used[fn.first][fn.second] = cu;
lvlT[fn.first][fn.second] = 0;
q.push(fn);
while (!q.empty()) {
pair<int, int> v = q.front();
q.pop();
for (int i = 0; i < int(4); ++i) {
pair<int, int> u(v.first + dx[i], v.second + dy[i]);
if (good(u) && isGood[a[u.first][u.second]] &&
used[u.first][u.second] < cu) {
used[u.first][u.second] = cu;
lvlT[u.first][u.second] = lvlT[v.first][v.second] + 1;
q.push(u);
}
}
}
while (!cur.empty()) {
char mn = 'z' + 1;
for (int i = 0; i < int(int((cur).size())); ++i)
for (int j = 0; j < int(4); ++j) {
pair<int, int> nx(cur[i].first + dx[j], cur[i].second + dy[j]);
if (good(nx) && used[nx.first][nx.second] == cu &&
lvl[nx.first][nx.second] + lvlT[nx.first][nx.second] ==
lvl[fn.first][fn.second] &&
lvl[nx.first][nx.second] == lvl[cur[i].first][cur[i].second] + 1) {
mn = min(mn, a[nx.first][nx.second]);
}
}
if (mn == 'z' + 1) throw;
if (mn == 'T') {
break;
} else {
res.push_back(mn);
vector<pair<int, int> > c2;
for (int i = 0; i < int(int((cur).size())); ++i)
for (int j = 0; j < int(4); ++j) {
pair<int, int> nx(cur[i].first + dx[j], cur[i].second + dy[j]);
if (good(nx) && a[nx.first][nx.second] == mn &&
used[nx.first][nx.second] == cu &&
lvl[nx.first][nx.second] ==
lvl[cur[i].first][cur[i].second] + 1) {
c2.push_back(nx);
}
}
sort((c2).begin(), (c2).end());
c2.erase(unique((c2).begin(), (c2).end()), c2.end());
cur = c2;
}
}
if (ans == "-1" || (int((ans).size()) > int((res).size()) ||
(int((ans).size()) == int((res).size()) && ans > res)))
ans = res;
}
void solve(int cnt, int idx, string& ans) {
if (cnt == k) {
for (int j = 0; j < int(k); ++j) isGood[tp[j]] = true;
updateAns(ans);
for (int j = 0; j < int(k); ++j) isGood[tp[j]] = false;
return;
}
for (int i = idx; i < szchrs; ++i) {
tp[cnt] = chrs[i];
solve(cnt + 1, i, ans);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) {
scanf(" %c", &a[i][j]);
if (a[i][j] == 'S') {
st = pair<int, int>(i, j);
continue;
}
if (a[i][j] == 'T') {
fn = pair<int, int>(i, j);
continue;
}
chrs[szchrs++] = a[i][j];
}
sort(chrs, chrs + szchrs);
szchrs = unique(chrs, chrs + szchrs) - chrs;
bs.first = 0;
bs.second = 0;
bt.first = n;
bt.second = m;
string ans = "-1";
isGood['S'] = true;
isGood['T'] = true;
for (int i = 0; i < int(4); ++i) {
sc = pair<int, int>(st.first + dx[i], st.second + dy[i]);
if (!good(sc)) continue;
tp[0] = a[sc.first][sc.second];
if (tp[0] == 'T') {
return 0;
}
solve(1, 0, ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
struct nd {
int x, y, h;
string s;
nd(){};
nd(int x, int y, int h, string s) : x(x), y(y), h(h), s(s){};
bool operator<(const nd &oth) const {
if (oth.s.length() != s.length()) return s.length() > oth.s.length();
return s > oth.s;
}
};
char a[55][55];
int n, m, mx;
set<int> s[55][55];
int lst[55][55];
int bitcnt(int x) {
int cnt = 0;
for (int i = 0; i < 26; i++)
if (x & (1 << i)) cnt++;
return cnt;
}
bool dijk(int i, int j) {
priority_queue<nd> pq;
pq.push(nd(i, j, 0, ""));
while (!pq.empty()) {
nd cur = pq.top();
pq.pop();
for (int k = 0; k < 4; k++) {
int x = cur.x + dx[k];
int y = cur.y + dy[k];
if (x < 0 || y < 0 || x >= n || y >= m) continue;
if (a[x][y] == 'T') {
cout << cur.s;
return true;
}
int h = cur.h | (1 << (a[x][y] - 'a'));
if (bitcnt(h) > mx || s[x][y].count(h)) continue;
if (lst[x][y] && (lst[x][y] & h) == lst[x][y]) continue;
lst[x][y] = h;
s[x][y].insert(h);
pq.push(nd(x, y, h, cur.s + a[x][y]));
}
}
return false;
}
int main() {
scanf("%d%d%d\n", &n, &m, &mx);
for (int i = 0; i < n; i++) scanf("%s", a[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (a[i][j] == 'S') {
if (!dijk(i, j)) printf("-1");
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
int n, m, k;
char mp[55][55], str[55 * 55];
int prei[55][55], prej[55][55], dis[55][55], vst[55][55];
int q2[2][55 * 55], r2[2], q[55 * 55];
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
bool used[55];
int res = 0x3f3f3f3f, si, ti, sj, tj;
void solve() {
memset(dis, 0x3f3f3f3f, sizeof(dis));
dis[ti][tj] = 0;
int l = 0, r = 0;
q[r++] = ti * m + tj;
while (l != r) {
int mask = q[l++];
int x = mask / m, y = mask % m;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (nx >= 0 && nx < n && ny >= 0 && ny < m &&
(mp[nx][ny] == 'S' || mp[nx][ny] == 'T' || used[mp[nx][ny] - 'a']) &&
dis[x][y] + 1 < dis[nx][ny]) {
dis[nx][ny] = dis[x][y] + 1;
q[r++] = nx * m + ny;
}
}
}
if (dis[si][sj] == 0x3f3f3f3f || dis[si][sj] > res) return;
bool ok = false;
if (dis[si][sj] < res) {
ok = true;
res = dis[si][sj];
}
memset(vst, 0, sizeof(vst));
bool id = false;
r2[id] = 0;
q2[id][r2[id]++] = si * m + sj;
for (int i = 0; i < dis[si][sj]; ++i) {
id = !id;
r2[id] = 0;
char mini = 'z' + 1;
for (int j = 0; j < r2[!id]; ++j) {
int mask = q2[!id][j];
int x = mask / m, y = mask % m;
if (mp[x][y] < mini) mini = mp[x][y];
}
if (!ok && mini > str[i + 1]) return;
if (mini < str[i + 1]) ok = true;
str[i + 1] = mini;
for (int j = 0; j < r2[!id]; ++j) {
int mask = q2[!id][j];
int x = mask / m, y = mask % m;
if (mp[x][y] == mini) {
for (int h = 0; h < 4; ++h) {
int nx = x + dx[h], ny = y + dy[h];
if (nx >= 0 && nx < n && ny >= 0 && ny < m &&
dis[x][y] - 1 == dis[nx][ny]) {
if (vst[nx][ny] != i + 1) {
vst[nx][ny] = i + 1;
q2[id][r2[id]++] = nx * m + ny;
}
}
}
}
}
}
}
void dfs(int dep, int count) {
if (dep == 26) {
if (count == k) solve();
return;
}
dfs(dep + 1, count);
if (count < k) {
used[dep] = true;
dfs(dep + 1, count + 1);
used[dep] = false;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
scanf("%s", mp[i]);
for (int j = 0; j < m; ++j)
if (mp[i][j] == 'S')
si = i, sj = j;
else if (mp[i][j] == 'T')
ti = i, tj = j;
}
dfs(0, 0);
if (res == 0x3f3f3f3f)
puts("-1");
else {
for (int i = 2; i <= res; ++i) putchar(str[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
struct kraw {
int a;
bool jest;
int kier;
};
int main() {
ios_base::sync_with_stdio(0);
int n, m, k;
cin >> n >> m >> k;
vector<string> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
vector<vector<kraw> > G(n * m);
int start, meta;
vector<char> lit(n * m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 'S') start = i * m + j;
if (a[i][j] == 'T') meta = i * m + j;
lit[i * m + j] = a[i][j];
for (int l = 0; l < 4; ++l) {
int x = i + dx[l], y = j + dy[l];
if (x >= 0 && x < n && y >= 0 && y < m) {
G[i * m + j].push_back({x * m + y, true, 0});
G[x * m + y].push_back({i * m + j, true, 0});
}
}
}
}
string odp = "";
for (int mask = 0; mask < (1 << 26); ++mask) {
if (__builtin_popcount(mask) != k) continue;
for (int i = 0; i < n * m; ++i) {
for (int j = 0; j < G[i].size(); ++j) {
G[i][j].jest = true;
G[i][j].kier = 0;
}
}
for (int i = 0; i < n * m; ++i)
for (int j = 0; j < G[i].size(); ++j)
if ((lit[i] != 'S' && lit[i] != 'T' &&
(mask & (1 << (lit[i] - 'a'))) == 0) ||
(lit[G[i][j].a] != 'S' && lit[G[i][j].a] != 'T' &&
(mask & (1 << (lit[G[i][j].a] - 'a'))) == 0))
G[i][j].jest = false;
queue<int> Q;
vector<int> odl(n * m, -1);
Q.push(start);
odl[start] = 0;
while (!Q.empty()) {
int akt = Q.front();
Q.pop();
for (int i = 0; i < G[akt].size(); ++i) {
if (G[akt][i].jest && odl[G[akt][i].a] == -1) {
Q.push(G[akt][i].a);
odl[G[akt][i].a] = odl[akt] + 1;
}
}
}
if (odl[meta] == -1) continue;
for (int i = 0; i < n * m; ++i) {
for (int j = 0; j < G[i].size(); ++j) {
if (G[i][j].jest) {
if (odl[i] == odl[G[i][j].a]) G[i][j].jest = false;
if (odl[i] < odl[G[i][j].a]) G[i][j].kier = 1;
if (odl[i] > odl[G[i][j].a]) G[i][j].kier = -1;
}
}
}
vector<int> st_wy(n * m, 0);
for (int i = 0; i < n * m; ++i)
for (int j = 0; j < G[i].size(); ++j)
if (G[i][j].jest && G[i][j].kier == 1) ++st_wy[i];
for (int i = 0; i < n * m; ++i)
if (st_wy[i] == 0) Q.push(i);
while (!Q.empty()) {
int akt = Q.front();
Q.pop();
if (akt == meta) continue;
for (int i = 0; i < G[akt].size(); ++i) {
if (G[akt][i].jest && G[akt][i].kier == -1) {
int pop = G[akt][i].a;
for (int j = 0; j < G[pop].size(); ++j)
if (G[pop][j].a == akt && G[pop][j].jest) G[pop][j].jest = false;
--st_wy[pop];
if (st_wy[pop] == 0) Q.push(pop);
}
}
}
string path = "S";
vector<int> a;
a.push_back(start);
while (path.size() < odl[meta]) {
char l = 'z';
for (int i = 0; i < a.size(); ++i)
for (int j = 0; j < G[a[i]].size(); ++j)
if (G[a[i]][j].jest && G[a[i]][j].kier == 1)
l = min(l, lit[G[a[i]][j].a]);
path += l;
vector<int> b;
set<int> S;
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < G[a[i]].size(); ++j) {
if (G[a[i]][j].jest && G[a[i]][j].kier == 1 &&
lit[G[a[i]][j].a] == l && S.find(G[a[i]][j].a) == S.end()) {
b.push_back(G[a[i]][j].a);
S.insert(G[a[i]][j].a);
}
}
}
a = b;
}
path += "T";
if (odp == "" || (odp != "" && path.size() < odp.size()) ||
(odp != "" && path.size() == odp.size() && path < odp))
odp = path;
}
if (odp == "")
cout << "-1";
else
for (int i = 1; i < odp.size() - 1; ++i) cout << odp[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string res = "-1", cur;
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = {0, 1, 0, -1};
int R, C, k, sr, sc, tr, tc, q[100000], f, l, r, c, nr, nc, d;
vector<int> p[50][50];
char s[50][51];
int cost[50][50];
bool in[27];
vector<int> push;
void build() {
q[f = l = 0] = tr;
q[++l] = tc;
cur = "";
while (f <= l) {
char mn = 28;
push.clear();
while (f <= l) {
r = q[f];
++f;
c = q[f];
++f;
for (int i = 0; i < p[r][c].size(); ++i) {
nr = r + dr[p[r][c][i]];
nc = c + dc[p[r][c][i]];
if (cost[nr][nc] == -1) continue;
cost[nr][nc] = -1;
if (s[nr][nc] < mn) {
mn = s[nr][nc];
push.clear();
}
if (s[nr][nc] == mn) {
push.push_back(nr);
push.push_back(nc);
}
}
}
if (mn == 26) break;
cur += mn + 'a';
for (int i = 0; i < push.size(); ++i) q[++l] = push[i];
}
if (res == "-1" || res.size() > cur.size() ||
res.size() == cur.size() && res > cur)
res = cur;
}
void BFS() {
for (int i = 0; i < R; ++i)
for (int j = 0; j < C; ++j) {
p[i][j].clear();
cost[i][j] = -1;
}
q[f = l = 0] = sr;
q[++l] = sc;
cost[sr][sc] = 0;
while (f <= l) {
r = q[f];
++f;
c = q[f];
++f;
if (r == tr && c == tc) {
build();
return;
}
for (int i = 0; i < 4; ++i) {
nr = r + dr[i];
nc = c + dc[i];
if (nr < 0 || nr == R || nc < 0 || nc == C || !in[s[nr][nc]]) continue;
if (cost[nr][nc] == -1) {
cost[nr][nc] = cost[r][c] + 1;
p[nr][nc].push_back((i + 2) & 3);
q[++l] = nr;
q[++l] = nc;
} else if (cost[nr][nc] == 1 + cost[r][c])
p[nr][nc].push_back((i + 2) & 3);
}
}
}
void calc(int i, int rem) {
if (!rem) {
BFS();
return;
}
if (i == 26) return;
in[i] = true;
calc(i + 1, rem - 1);
in[i] = false;
calc(i + 1, rem);
}
int main() {
scanf("%d%d%d", &R, &C, &k);
for (int i = 0; i < R; ++i) {
scanf("%s", s[i]);
for (int j = 0; j < C; ++j)
if (s[i][j] == 'S') {
tr = i;
tc = j;
s[i][j] = 26;
} else if (s[i][j] == 'T') {
sr = i;
sc = j;
s[i][j] = 26;
} else
s[i][j] -= 'a';
}
in[26] = true;
calc(0, k);
puts(res.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[52][52];
int road[52][52];
int n, m, k;
int sx, sy, ex, ey;
int able[52 * 52];
string bst;
int sequence[52 * 52 * 8];
int afk[52][52];
int vis[52][52];
pair<int, int> pre[52][52];
int ax[] = {-1, 1, 0, 0}, ay[] = {0, 0, -1, 1};
void trysolve() {
memset(vis, 0x3f, sizeof vis);
memset(afk, 0x3f, sizeof afk);
queue<pair<int, int> > q[2];
int now = 0;
vis[sx][sy] = 1;
q[now].push(make_pair(sx, sy));
afk[sx][sy] = 1;
while (q[now].size() and vis[ex][ey] > 1e8) {
vector<pair<int, int> > all;
while (q[now].size()) {
int x = q[now].front().first, y = q[now].front().second;
q[now].pop();
for (int i = 0; i < 4; i++) {
int tx = x + ax[i], ty = y + ay[i];
if (str[tx][ty] != 'T' and !able[road[tx][ty]]) continue;
int ene = afk[x][y] * 5 + able[road[tx][ty]];
if (vis[tx][ty] > vis[x][y] + 1) {
vis[tx][ty] = vis[x][y] + 1;
afk[tx][ty] = ene;
all.push_back(make_pair(tx, ty));
pre[tx][ty] = make_pair(x, y);
} else if (vis[tx][ty] == vis[x][y] + 1 and afk[tx][ty] > ene) {
afk[tx][ty] = ene;
pre[tx][ty] = make_pair(x, y);
}
}
}
int upp = 0;
for (int i = 0; i < all.size(); i++)
sequence[afk[all[i].first][all[i].second]] = 1,
upp = max(upp, afk[all[i].first][all[i].second]);
int tot = 0;
for (int i = 1; i <= upp; i++)
if (sequence[i]) sequence[i] = ++tot;
for (int i = 0; i < all.size(); i++)
afk[all[i].first][all[i].second] =
sequence[afk[all[i].first][all[i].second]];
for (int i = 1; i <= upp; i++)
if (sequence[i]) sequence[i] = 0;
now ^= 1;
for (int i = 0; i < all.size(); i++) q[now].push(all[i]);
}
if (vis[ex][ey] < 1e8) {
int x = pre[ex][ey].first, y = pre[ex][ey].second;
string gg;
while (x != sx or y != sy) {
gg += char('a' - 1 + road[x][y]);
pair<int, int> op = pre[x][y];
x = op.first, y = op.second;
}
reverse(gg.begin(), gg.end());
if (bst.size() > gg.size()) bst = gg;
if (bst.size() == gg.size()) bst = min(bst, gg);
}
}
void solve(int xk, int cnt) {
if (cnt > k) return;
if (xk == 27) trysolve();
if (xk == 27) return;
solve(xk + 1, cnt);
able[xk] = cnt + 1;
solve(xk + 1, cnt + 1);
able[xk] = 0;
}
signed main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%s", str[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (str[i][j] == 'S') sx = i, sy = j;
if (str[i][j] == 'T') ex = i, ey = j;
bst += 'o';
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) road[i][j] = str[i][j] - 'a' + 1;
solve(1, 0);
if (bst.size() >= n * m) bst = "-1";
cout << bst;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const int INF = (int)1E9 + 7;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int NMAX = 52;
char a[NMAX][NMAX];
int n, m, k;
pair<int, int> s, t;
bool can[300];
const string FAIL = "$";
string ans = FAIL;
void upd(const string& s) {
if (s == FAIL) return;
if (ans == FAIL)
ans = s;
else {
if (int((ans).size()) > int((s).size()) ||
(int((ans).size()) == int((s).size()) && ans > s))
ans = s;
}
}
int d1[NMAX][NMAX], d2[NMAX][NMAX];
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
inline bool in(const pair<int, int>& nv) {
return !(nv.first < 0 || nv.first >= n || nv.second < 0 || nv.second >= m);
}
void genD(pair<int, int> s, int d[NMAX][NMAX]) {
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) d[i][j] = INF;
queue<pair<int, int> > q;
q.push(s), d[s.first][s.second] = 0;
while (!q.empty()) {
pair<int, int> v = q.front();
q.pop();
for (int i = 0; i < int(4); ++i) {
pair<int, int> nv(v.first + dx[i], v.second + dy[i]);
if (!in(nv)) continue;
if (!can[a[nv.first][nv.second]]) continue;
if (d[nv.first][nv.second] > d[v.first][v.second] + 1) {
d[nv.first][nv.second] = d[v.first][v.second] + 1;
q.push(nv);
}
}
}
}
string get() {
genD(s, d1);
genD(t, d2);
if (d1[t.first][t.second] > INF / 2) return FAIL;
string ans;
vector<pair<int, int> > q;
q.push_back(s);
for (int step = 0; step < int(d1[t.first][t.second]); ++step) {
vector<pair<int, int> > nq;
char minC = -1;
for (int i = 0; i < int(int((q).size())); ++i) {
pair<int, int> v = q[i];
for (int j = 0; j < int(4); ++j) {
pair<int, int> nv(v.first + dx[j], v.second + dy[j]);
if (!in(nv) || !can[a[nv.first][nv.second]]) continue;
if (d1[nv.first][nv.second] + d2[nv.first][nv.second] !=
d1[t.first][t.second])
continue;
if (d1[nv.first][nv.second] <= d1[v.first][v.second]) continue;
if (minC == -1) minC = a[nv.first][nv.second];
minC = min(minC, a[nv.first][nv.second]);
}
}
ans += minC;
for (int i = 0; i < int(int((q).size())); ++i) {
pair<int, int> v = q[i];
for (int j = 0; j < int(4); ++j) {
pair<int, int> nv(v.first + dx[j], v.second + dy[j]);
if (!in(nv) || !can[a[nv.first][nv.second]]) continue;
if (d1[nv.first][nv.second] + d2[nv.first][nv.second] !=
d1[t.first][t.second])
continue;
if (d1[nv.first][nv.second] <= d1[v.first][v.second]) continue;
if (a[nv.first][nv.second] != minC) continue;
nq.push_back(nv);
}
}
sort((nq).begin(), (nq).end());
nq.erase(unique((nq).begin(), (nq).end()), nq.end());
q = nq;
}
assert(int((q).size()) == 1 && q[0] == t);
ans.erase(int((ans).size()) - 1);
return ans;
}
void brute(char c, int cnt) {
if (cnt > k) return;
if (cnt == k) {
upd(get());
return;
}
if (c > 'z') return;
can[c] = true;
brute(c + 1, cnt + 1);
can[c] = false;
brute(c + 1, cnt);
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) {
scanf(" %c ", &a[i][j]);
if (a[i][j] == 'S') s = pair<int, int>(i, j);
if (a[i][j] == 'T') t = pair<int, int>(i, j);
}
can['S'] = true, can['T'] = true;
brute('a', 0);
if (ans == FAIL)
puts("-1");
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Rohan {
int x, y;
int d, mask;
string s;
};
struct compare {
bool operator()(Rohan a, Rohan b) {
if (a.d == b.d) {
return (a.s > b.s);
} else {
return (a.d > b.d);
}
}
};
int distance(int x, int y, int a, int b) { return (abs(x - a) + abs(y - b)); }
const int mx = 55;
string a[mx];
int n, m, k, sx, sy, tx, ty;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
bool safe(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && a[x][y] != 'S');
}
int countBit(int n) {
int ans = 0;
while (n > 0) {
int d = n % 2;
n = n / 2;
ans = ans + (d == 1);
}
return ans;
}
string bfs() {
Rohan r = {sx, sy, distance(sx, sy, tx, ty), 0, ""};
priority_queue<Rohan, vector<Rohan>, compare> pq;
set<pair<int, pair<int, int> > > s;
pq.push(r);
while (pq.empty() == false) {
r = pq.top();
pq.pop();
if (a[r.x][r.y] == 'T') {
return r.s;
}
if (s.find(make_pair(r.mask, make_pair(r.x, r.y))) != s.end()) {
continue;
}
s.insert(make_pair(r.mask, make_pair(r.x, r.y)));
for (int i = 0; i < 4; i++) {
int row = r.x + dx[i];
int col = r.y + dy[i];
if (safe(row, col) == false) {
continue;
}
if (row == tx && col == ty) {
return r.s;
}
int next = r.mask | (1 << (a[row][col] - 97));
if (countBit(next) <= k) {
Rohan temp;
temp.x = row;
temp.y = col;
temp.s = r.s + a[row][col];
temp.d = distance(row, col, tx, ty) + r.s.length();
temp.mask = next;
pq.push(temp);
}
}
}
return "-1";
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'S') {
sx = i;
sy = j;
} else if (a[i][j] == 'T') {
tx = i;
ty = j;
}
}
}
cout << bfs();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dirx[4] = {-1, 0, 0, 1};
int diry[4] = {0, -1, 1, 0};
int qx[100001], head, tail, qy[100001];
int ena[100001], ech[100001];
int stx, sty, enx, eny;
int res;
char ress[3001], s[3001];
int n, m, k;
char g[100][100];
int ans[3001];
int f[100][100];
int now;
int vis[100][100];
inline void work() {
now++;
g[stx][sty] = ech[1];
qx[head = tail = 0] = enx, qy[0] = eny;
memset(f, 63, sizeof(f));
f[enx][eny] = 0;
while (head <= tail) {
int x = qx[head], y = qy[head++];
for (int i = 0; i < 4; ++i) {
int xx = x + dirx[i], yy = y + diry[i];
if (xx < 0 || yy < 0 || xx >= n || yy >= m || !ena[g[xx][yy]]) continue;
if (f[xx][yy] > f[x][y] + 1) {
f[xx][yy] = f[x][y] + 1;
qx[++tail] = xx, qy[tail] = yy;
}
}
}
if (f[stx][sty] > res) return;
memset(ans, 63, sizeof(ans));
ans[f[stx][sty]] = ech[1];
qx[head = tail = 0] = stx, qy[0] = sty;
while (head <= tail) {
int x = qx[head], y = qy[head++];
if (ans[f[x][y]] != g[x][y]) continue;
for (int i = 0; i < 4; ++i) {
int xx = x + dirx[i], yy = y + diry[i];
if (xx < 0 || yy < 0 || xx >= n || yy >= m || !ena[g[xx][yy]]) continue;
if (f[xx][yy] == f[x][y] - 1 && vis[xx][yy] != now) {
ans[f[xx][yy]] =
((ans[f[xx][yy]]) < (g[xx][yy]) ? (ans[f[xx][yy]]) : (g[xx][yy]));
qx[++tail] = xx, qy[tail] = yy;
vis[xx][yy] = now;
}
}
}
int sn = 0;
for (int i = f[stx][sty] - 1; i > 0; --i) s[sn++] = ans[i] + 'a';
s[sn] = 0;
if (res > f[stx][sty] || res == f[stx][sty] && strcmp(s, ress) == -1)
res = f[stx][sty], memcpy(ress, s, sizeof(s));
}
inline void dfs(int p, int la) {
if (p > k) {
work();
return;
}
for (int i = la; i < 26; ++i) {
ena[i] = 1;
ech[p] = i;
dfs(p + 1, i + 1);
ena[i] = 0;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
scanf("%s", g[i]);
for (int j = 0; j < m; ++j)
if (g[i][j] == 'S')
stx = i, sty = j;
else if (g[i][j] == 'T')
enx = i, eny = j;
else
g[i][j] -= 'a';
}
res = 214748364;
dfs(1, 0);
if (res == 214748364)
printf("-1\n");
else
printf("%s\n", ress);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k;
unordered_map<char, int> used;
const int N = 55;
int inf = 1e9, dp[N][N], n, m, sx, sy;
char s[N][N];
int tx, ty, best = inf, pos[N][N];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
string BEST = "-1";
void solve() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j] = inf;
pos[i][j] = 0;
}
}
dp[tx][ty] = 0;
queue<pair<int, int> > q;
q.push(make_pair(tx, ty));
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (used[s[nx][ny]] && dp[nx][ny] == inf) {
dp[nx][ny] = dp[x][y] + 1;
q.push(make_pair(nx, ny));
}
}
}
if (dp[sx][sy] == inf || dp[sx][sy] > best) {
return;
}
best = dp[sx][sy];
vector<pair<int, int> > v;
v.push_back(make_pair(sx, sy));
pos[sx][sy] = 1;
string ans;
while (1) {
vector<pair<int, int> > nv;
char mn = 'z' + 1;
for (auto i : v) {
int x = i.first;
int y = i.second;
for (int j = 0; j < 4; j++) {
int nx = x + dx[j];
int ny = y + dy[j];
if (dp[x][y] - 1 == dp[nx][ny] && used[s[nx][ny]]) {
if (mn > s[nx][ny] && !pos[nx][ny]) {
nv.clear();
nv.push_back(make_pair(nx, ny));
mn = s[nx][ny];
pos[nx][ny] = 1;
} else if (mn == s[nx][ny] && !pos[nx][ny]) {
nv.push_back(make_pair(nx, ny));
pos[nx][ny] = 1;
}
}
}
}
if (mn == 'T') {
if (BEST == "-1" || BEST.size() > ans.size() || BEST > ans) {
BEST = ans;
}
return;
}
ans += mn;
v = nv;
}
}
void rec(int x, int cnt) {
if (x == 26) {
solve();
return;
}
used[char(x + 'a')] = 0;
rec(x + 1, cnt);
if (cnt == k) return;
used[char(x + 'a')] = 1;
rec(x + 1, cnt + 1);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++) {
if (s[i][j] == 'S') {
sx = i;
sy = j;
} else if (s[i][j] == 'T') {
tx = i;
ty = j;
}
}
}
used['S'] = used['T'] = 1;
rec(0, 0);
cout << BEST;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int main() {
long long n, m, k, sx, sy, tx, ty;
cin >> n >> m >> k;
vector<string> mp(n);
for (long long i = 0; i < ((long long)n); i++) cin >> mp[i];
for (long long i = 0; i < ((long long)n); i++)
for (long long j = 0; j < ((long long)m); j++)
if (mp[i][j] == 'S') sx = i, sy = j;
for (long long i = 0; i < ((long long)n); i++)
for (long long j = 0; j < ((long long)m); j++)
if (mp[i][j] == 'T') tx = i, ty = j;
priority_queue<
pair<int, pair<pair<string, int>, pair<int, int> > >,
vector<pair<int, pair<pair<string, int>, pair<int, int> > > >,
greater<pair<int, pair<pair<string, int>, pair<int, int> > > > >
q;
q.push(make_pair((abs((sx) - (tx)) + abs((sy) - (ty))),
make_pair(make_pair("", 0), make_pair(sx, sy))));
set<pair<int, pair<int, int> > > s;
while (((long long)q.size())) {
pair<int, pair<pair<string, int>, pair<int, int> > > pp = q.top();
pair<pair<string, int>, pair<int, int> > p = pp.second;
q.pop();
string str = p.first.first;
int mask = p.first.second;
int x = p.second.first;
int y = p.second.second;
if (s.find(make_pair(mask, make_pair(x, y))) != s.end()) continue;
s.insert(make_pair(mask, make_pair(x, y)));
for (long long i = 0; i < ((long long)4); i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx < 0 || n <= xx || yy < 0 || m <= yy) continue;
if (mp[xx][yy] == 'T') {
cout << str << endl;
return 0;
}
if ('a' <= mp[xx][yy] && mp[xx][yy] <= 'z') {
int next = (1 << (mp[xx][yy] - 'a')) | mask;
if (k < __builtin_popcount(next)) continue;
q.push(make_pair(
((long long)str.size()) + 1 + (abs((xx) - (tx)) + abs((yy) - (ty))),
make_pair(make_pair(str + string(1, mp[xx][yy]), next),
make_pair(xx, yy))));
}
}
}
cout << "-1" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(string a, string b) {
if (a.length() != b.length()) return a.length() < b.length();
return a < b;
}
struct node {
int x, y, mask;
string path;
node() {}
node(int x, int y, int m, string p) : x(x), y(y), mask(m), path(p) {}
bool operator<(const node &p) const { return cmp(p.path, path); }
};
char s[55][55];
set<int> vis[55][55];
int f[55][55];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
string bfs(int x, int y, int k) {
string res(55 * 55, 'a');
priority_queue<node> q;
q.push(node(x, y, 0, ""));
vis[x][y].insert(0);
f[x][y] = 0;
while (!q.empty()) {
node u = q.top();
q.pop();
for (int i = 0; i < 4; i++) {
int x = u.x + dx[i], y = u.y + dy[i];
if (!s[x][y] || s[x][y] == 'S') continue;
if (s[x][y] == 'T') {
if (cmp(u.path, res)) res = u.path;
break;
}
int z = u.mask | (1 << (s[x][y] - 'a'));
if (__builtin_popcount(z) > k) continue;
if (vis[x][y].count(z)) continue;
if (f[x][y] && (f[x][y] & z) == f[x][y]) continue;
vis[x][y].insert(z);
f[x][y] = z;
q.push(node(x, y, z, u.path + s[x][y]));
}
}
if (res.length() == 55 * 55) res = "-1";
return res;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (s[i][j] == 'S') {
cout << bfs(i, j, k) << endl;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> enumerate(int k) {
vector<vector<int> > cur(k + 1);
cur[0].push_back(0);
cur[1].push_back(1);
for (int i = 1; i < 26; i++) {
vector<vector<int> > ncur = cur;
for (int j = 1; j <= k && j <= i + 1; j++) {
for (auto x : cur[j - 1]) {
ncur[j].push_back(x ^ (1 << i));
}
}
cur = ncur;
}
vector<int> ret;
for (int i = 1; i <= k; i++) {
for (int x : cur[i]) {
ret.push_back(x);
}
}
return ret;
}
const int N = 55;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
string t[N];
int n, m, k, px[N][N], py[N][N], dist[N][N];
inline void bfs(int x, int y) {
memset(dist, -1, sizeof(dist));
dist[x][y] = 0;
queue<int> qx, qy;
qx.push(x);
qy.push(y);
while (!qx.empty()) {
x = qx.front();
qx.pop();
y = qy.front();
qy.pop();
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || t[nx][ny] == '#') continue;
if (dist[nx][ny] == -1) {
dist[nx][ny] = dist[x][y] + 1;
qx.push(nx);
qy.push(ny);
}
}
}
}
inline string getString(int sx, int sy, int fx, int fy) {
string ret = "";
vector<pair<int, int> > pos({{sx, sy}});
int len = dist[sx][sy] - 1;
for (int i = 0; i < len; i++) {
vector<pair<int, int> > npos[26];
for (auto pp : pos) {
int x = pp.first;
int y = pp.second;
for (int j = 0; j < 4; j++) {
int nx = x + dx[j];
int ny = y + dy[j];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || t[nx][ny] == '#')
continue;
if (dist[nx][ny] + 1 == dist[x][y]) {
npos[t[nx][ny] - 'a'].push_back({nx, ny});
}
}
}
for (int j = 0; j < 26; j++) {
if (!npos[j].empty()) {
ret += char('a' + j);
pos = npos[j];
break;
}
}
sort(pos.begin(), pos.end());
pos.resize(unique(pos.begin(), pos.end()) - pos.begin());
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
cin >> n >> m >> k;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
vector<int> masks = enumerate(k);
string ans = "";
bool flg = false;
for (auto mask : masks) {
int sx, sy, fx, fy;
for (int i = 0; i < n; i++) {
t[i] = s[i];
for (int j = 0; j < m; j++) {
if (t[i][j] == 'S') {
sx = i;
sy = j;
} else if (t[i][j] == 'T') {
fx = i;
fy = j;
} else {
int ch = t[i][j] - 'a';
if (((mask >> ch) & 1) == 0) t[i][j] = '#';
}
}
}
bfs(fx, fy);
if (dist[sx][sy] == -1) continue;
string cur = getString(sx, sy, fx, fy);
bitset<26> bt(mask);
if (flg) {
if (ans.size() > cur.size())
ans = cur;
else if (ans.size() == cur.size())
ans = min(ans, cur);
} else {
ans = cur;
flg = true;
}
}
if (flg)
cout << ans;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char g[55][55];
int nr, nc, k;
int tr, tc, sr, sc;
int mincost = -1;
char chosen[5];
bool seen[500];
char ans[3000];
int dr[] = {-1, 1, 0, 0};
int dc[] = {0, 0, 1, -1};
void check() {
int d[55][55];
memset((d), (-1), sizeof(d));
d[tr][tc] = 0;
queue<int> q;
q.push(tr);
q.push(tc);
while (!q.empty()) {
int r = q.front();
q.pop();
int c = q.front();
q.pop();
int dist = d[r][c] + 1;
for (int i = 0, _e(4); i < _e; i++) {
int rr = r + dr[i], cc = c + dc[i];
if (rr < 0 || cc < 0 || rr >= nr || cc >= nc ||
(g[rr][cc] != 'S' && !seen[g[rr][cc] - 'a']))
continue;
if (d[rr][cc] == -1 || d[rr][cc] > dist) {
d[rr][cc] = dist;
q.push(rr);
q.push(cc);
}
}
}
if (d[sr][sc] != -1 && (mincost == -1 || mincost >= d[sr][sc])) {
if (mincost == -1 || mincost > d[sr][sc]) {
mincost = d[sr][sc];
queue<int> q;
int r = sr, c = sc;
q.push(r);
q.push(c);
for (int j = 0, _e(mincost - 1); j < _e; j++) {
int tot = q.size() / 2;
char minC = 'z';
queue<int> p;
int taken[55][55] = {}, take = 1;
for (int l = 0, _e(tot); l < _e; l++) {
r = q.front();
q.pop();
c = q.front();
q.pop();
int look = mincost - j - 1;
for (int i = 0, _e(4); i < _e; i++) {
int rr = r + dr[i], cc = c + dc[i];
if (rr < 0 || cc < 0 || rr >= nr || cc >= nc ||
(!seen[g[rr][cc] - 'a']))
continue;
if (d[rr][cc] == look) {
if (g[rr][cc] < minC) {
while (p.size()) p.pop();
++take, minC = g[rr][cc], p.push(rr), p.push(cc),
taken[rr][cc] = take;
} else if (g[rr][cc] == minC && taken[rr][cc] != take) {
p.push(rr), p.push(cc), taken[rr][cc] = take;
}
}
}
}
ans[j] = minC;
q = p;
}
} else {
queue<int> q;
int r = sr, c = sc;
q.push(r);
q.push(c);
char dans[3000];
for (int j = 0, _e(mincost - 1); j < _e; j++) {
int tot = q.size() / 2;
char minC = 'z';
queue<int> p;
int taken[55][55] = {}, take = 0;
for (int l = 0, _e(tot); l < _e; l++) {
r = q.front();
q.pop();
c = q.front();
q.pop();
int look = mincost - j - 1;
for (int i = 0, _e(4); i < _e; i++) {
int rr = r + dr[i], cc = c + dc[i];
if (rr < 0 || cc < 0 || rr >= nr || cc >= nc ||
(!seen[g[rr][cc] - 'a']))
continue;
if (d[rr][cc] == look) {
if (g[rr][cc] < minC) {
while (p.size()) p.pop();
++take, minC = g[rr][cc], p.push(rr), p.push(cc),
taken[rr][cc] = take;
} else if (g[rr][cc] == minC && taken[rr][cc] != take) {
p.push(rr), p.push(cc), taken[rr][cc] = take;
}
}
}
}
dans[j] = minC;
q = p;
}
bool better = 0;
for (int i = 0, _e(mincost - 1); i < _e; i++)
if (ans[i] < dans[i])
break;
else if (ans[i] > dans[i])
better = 1;
if (better) {
for (int i = 0, _e(mincost - 1); i < _e; i++) ans[i] = dans[i];
}
}
}
}
void dfs(int p, int last) {
if (p) check();
if (p == k) return;
for (int i(last), _e(25); i <= _e; i++)
if (!seen[i]) {
seen[i] = 1;
chosen[p] = i + 'a';
dfs(p + 1, i + 1);
seen[i] = 0;
}
}
int main() {
cin >> nr >> nc >> k;
for (int i = 0, _e(nr); i < _e; i++) cin >> g[i];
for (int i = 0, _e(nr); i < _e; i++)
for (int j = 0, _e(nc); j < _e; j++)
if (g[i][j] == 'T')
tr = i, tc = j;
else if (g[i][j] == 'S')
sr = i, sc = j;
dfs(0, 0);
if (mincost == -1) {
cout << -1 << endl;
return 0;
}
for (int i = 0, _e(mincost - 1); i < _e; i++) cout << ans[i];
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 50 + 10;
char board[M][M];
char graph[M][M];
struct NODE {
int parent_row;
int parent_col;
int dis;
int visited;
string par;
} node[M][M];
int cnt = 0;
int pattern[26 * 25 * 23 + 10][4];
void nchoosek(int num, int *a, int tar, int len, int isize, int spe) {
if (isize == tar) {
int j = 0;
for (int i = 0; i < len; i++) {
if (a[i] == 1) {
pattern[cnt][j] = i;
j++;
}
}
cnt++;
return;
} else {
for (int i = num; i < len; i++) {
if (i != spe) {
a[i] = 1;
nchoosek(i + 1, a, tar, len, isize + 1, spe);
a[i] = 0;
}
}
return;
}
}
string ans;
int LEN = 1E+9;
int dir[8] = {0, 1, 0, -1, -1, 0, 1, 0};
int n, m;
void BFS(int sr, int sc, int er, int ec) {
queue<pair<int, int> > Q;
Q.push(make_pair(sr, sc));
node[sr][sc].visited = 1;
node[sr][sc].dis = 0;
while (!Q.empty()) {
int row = Q.front().first;
int col = Q.front().second;
Q.pop();
for (int i = 0; i < 8; i = i + 2) {
int nrow = row + dir[i];
int ncol = col + dir[i + 1];
if (nrow >= 0 && nrow < n && ncol >= 0 && ncol < m &&
(graph[nrow][ncol] == 'O' || graph[nrow][ncol] == 'T')) {
if (node[nrow][ncol].visited == 1) {
if (node[nrow][ncol].dis == node[row][col].dis + 1) {
int prow = node[nrow][ncol].parent_row;
int pcol = node[nrow][ncol].parent_col;
if (node[row][col].par < node[prow][pcol].par) {
node[nrow][ncol].parent_row = row;
node[nrow][ncol].parent_col = col;
node[nrow][ncol].par = node[row][col].par + board[nrow][ncol];
}
}
} else {
node[nrow][ncol].parent_row = row;
node[nrow][ncol].parent_col = col;
node[nrow][ncol].dis = node[row][col].dis + 1;
node[nrow][ncol].visited = 1;
node[nrow][ncol].par = node[row][col].par + board[nrow][ncol];
if (nrow == er && ncol == ec) {
;
} else {
Q.push(make_pair(nrow, ncol));
}
}
}
}
}
if (node[er][ec].visited == 1) {
int row = er;
int col = ec;
vector<char> tmp;
while (row != sr || col != sc) {
tmp.push_back(board[row][col]);
int irow = node[row][col].parent_row;
int icol = node[row][col].parent_col;
row = irow;
col = icol;
}
tmp.push_back(board[sr][sc]);
if (tmp.size() < LEN) {
ans = "";
for (int i = tmp.size() - 1; i >= 0; i--) {
ans = ans + tmp[i];
}
LEN = tmp.size();
} else {
if (tmp.size() == LEN) {
string ss = "";
for (int i = tmp.size() - 1; i >= 0; i--) {
ss += tmp[i];
}
if (ss < ans) {
ans = ss;
}
}
}
}
return;
}
int main() {
int k;
cin >> n >> m >> k;
set<char> letter;
int sr, sc;
int er, ec;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
board[i][j] = s[j];
if (s[j] == 'S') {
sr = i;
sc = j;
}
if (s[j] == 'T') {
er = i;
ec = j;
}
if (s[j] != 'S' && s[j] != 'T') {
letter.insert(s[j]);
}
}
}
vector<char> grid;
for (set<char>::iterator it = letter.begin(); it != letter.end(); it++) {
grid.push_back(*it);
}
sort(grid.begin(), grid.end());
if (grid.size() < k) {
k = grid.size();
}
for (int kk = 0; kk < 8; kk += 2) {
int isr = sr + dir[kk];
int isc = sc + dir[kk + 1];
if (isr >= 0 && isr < n && isc >= 0 && isc < m) {
for (int ksize = 1; ksize <= k; ksize++) {
cnt = 0;
int a[26];
for (int j = 0; j < grid.size(); j++) {
a[j] = 0;
}
char cc = board[isr][isc];
int inum = -1;
for (int ii = 0; ii < grid.size(); ii++) {
if (grid[ii] == cc) {
inum = ii;
break;
}
}
a[inum] = 1;
nchoosek(0, a, ksize, grid.size(), 1, inum);
for (int i = 0; i < cnt; i = i + 1) {
for (int row = 0; row < n; row++) {
for (int col = 0; col < m; col++) {
if (board[row][col] == 'S') {
graph[row][col] = 'S';
}
if (board[row][col] == 'T') {
graph[row][col] = 'T';
}
if (board[row][col] != 'S' && board[row][col] != 'T') {
graph[row][col] = 'X';
for (int j = 0; j < ksize; j++) {
if (board[row][col] == grid[pattern[i][j]]) {
graph[row][col] = 'O';
}
}
}
node[row][col].visited = 0;
}
}
BFS(isr, isc, er, ec);
}
}
}
}
if (LEN == 1E+9) {
if (n * m > 2) cout << "-1" << endl;
} else {
for (int i = 0; i < ans.size() - 1; i++) {
cout << ans[i];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
pair<int, int> st, en;
int m, n, k;
char a[55][55];
bool b[55][55];
int d[55][55];
string Z[55][55];
bool inq[55][55];
int solve1() {
queue<pair<int, int> > q;
q.push(st);
memset(d, 0x1f, sizeof(d));
d[st.first][st.second] = 0;
while (!q.empty()) {
int u = q.front().first;
int v = q.front().second;
q.pop();
for (int h = 0; h < (4); ++h) {
int x = u + dx[h];
int y = v + dy[h];
if (0 <= x && x < m && 0 <= y && y < n && b[x][y]) {
if (d[x][y] > d[u][v] + 1) {
d[x][y] = d[u][v] + 1;
q.push(make_pair(x, y));
}
}
}
}
return d[en.first][en.second];
}
string solve2() {
queue<pair<int, int> > q;
memset(inq, 0, sizeof(inq));
q.push(st);
inq[st.first][st.second] = true;
Z[st.first][st.second] = "";
while (!q.empty()) {
int u = q.front().first;
int v = q.front().second;
q.pop();
for (int h = 0; h < (4); ++h) {
int x = u + dx[h];
int y = v + dy[h];
if (0 <= x && x < m && 0 <= y && y < n && b[x][y]) {
if (d[x][y] == d[u][v] + 1) {
if (!inq[x][y]) {
q.push(make_pair(x, y));
inq[x][y] = true;
Z[x][y] = Z[u][v] + a[x][y];
} else if (Z[x][y] > Z[u][v] + a[x][y])
Z[x][y] = Z[u][v] + a[x][y];
}
}
}
}
return Z[en.first][en.second];
}
int main() {
scanf("%d%d%d", &m, &n, &k);
gets(a[0]);
for (int i = 0; i < (m); ++i) gets(a[i]);
for (int i = 0; i < (m); ++i)
for (int j = 0; j < (n); ++j)
if (a[i][j] == 'S')
st = make_pair(i, j);
else if (a[i][j] == 'T')
en = make_pair(i, j);
int res = 50 * 50 * 50;
for (int c1 = 0; c1 < (26); ++c1)
for (int c2 = 0; c2 < (c1 + 1); ++c2)
for (int c3 = 0; c3 < (c2 + 1); ++c3)
for (int c4 = 0; c4 < (c3 + 1); ++c4) {
set<int> second;
second.insert(c1);
second.insert(c2);
second.insert(c3);
second.insert(c4);
if (second.size() == k) {
memset(b, 0, sizeof(b));
for (int i = 0; i < (m); ++i)
for (int j = 0; j < (n); ++j)
if (a[i][j] == 'S' || a[i][j] == 'T' ||
second.count(a[i][j] - 'a'))
b[i][j] = true;
int len = solve1();
res = min(res, len);
}
}
if (res == 50 * 50 * 50)
cout << -1 << endl;
else {
string beststr = "";
for (int c1 = 0; c1 < (26); ++c1)
for (int c2 = 0; c2 < (c1 + 1); ++c2)
for (int c3 = 0; c3 < (c2 + 1); ++c3)
for (int c4 = 0; c4 < (c3 + 1); ++c4) {
set<int> second;
second.insert(c1);
second.insert(c2);
second.insert(c3);
second.insert(c4);
if (second.size() == k) {
memset(b, 0, sizeof(b));
for (int i = 0; i < (m); ++i)
for (int j = 0; j < (n); ++j)
if (a[i][j] == 'S' || a[i][j] == 'T' ||
second.count(a[i][j] - 'a'))
b[i][j] = true;
int len = solve1();
if (len == res) {
string path = solve2();
if (beststr == "" || beststr > path) beststr = path;
}
}
}
beststr = beststr.substr(0, beststr.length() - 1);
cout << beststr << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int sz = 1 << 15;
char inbuf[sz], outbuf[sz];
char *pinbuf = inbuf + sz;
char *poutbuf = outbuf;
inline char _getchar() {
if (pinbuf == inbuf + sz) fread(inbuf, 1, sz, stdin), pinbuf = inbuf;
return *(pinbuf++);
}
inline void _putchar(char x) {
if (poutbuf == outbuf + sz) fwrite(outbuf, 1, sz, stdout), poutbuf = outbuf;
*(poutbuf++) = x;
}
inline void flush() {
if (poutbuf != outbuf)
fwrite(outbuf, 1, poutbuf - outbuf, stdout), poutbuf = outbuf;
}
} // namespace IO
inline int read() {
int x = 0, p = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
return x * p;
}
namespace Mymath {
long long qp(long long x, long long p, long long mod) {
long long ans = 1;
while (p) {
if (p & 1) ans = ans * x % mod;
x = x * x % mod;
p >>= 1;
}
return ans;
}
long long inv(long long x, long long mod) { return qp(x, mod - 2, mod); }
long long C(long long N, long long K, long long fact[], long long mod) {
return fact[N] * inv(fact[K], mod) % mod * inv(fact[N - K], mod) % mod;
}
template <typename Tp>
Tp gcd(Tp A, Tp B) {
if (B == 0) return A;
return gcd(B, A % B);
}
template <typename Tp>
Tp lcm(Tp A, Tp B) {
return A * B / gcd(A, B);
}
}; // namespace Mymath
const int Maxn = 55;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
char c[Maxn][Maxn];
int n, m, k, sx, sy, ex, ey;
vector<vector<int> > V;
vector<int> now;
void dfs(int lvl) {
if (lvl == k) {
V.push_back(now);
return;
}
int lst = (now.empty()) ? 0 : now.back() + 1;
for (int i = lst; i < 26; i++) {
now.push_back(i);
dfs(lvl + 1);
now.pop_back();
}
}
int ds[Maxn][Maxn], dt[Maxn][Maxn];
bool G[27];
int qx[Maxn * Maxn], qy[Maxn * Maxn], eq, kq;
void bfs(int x, int y, int dist[Maxn][Maxn]) {
for (int i = 0; i < Maxn; i++) {
for (int j = 0; j < Maxn; j++) {
dist[i][j] = -1;
}
}
dist[x][y] = 0;
kq = eq = 0;
qx[eq] = x;
qy[eq++] = y;
while (kq < eq) {
int X = qx[kq], Y = qy[kq++];
for (int i = 0; i < 4; i++) {
int nx = X + dx[i], ny = Y + dy[i];
if (nx >= 0 && ny >= 0 && nx < n && ny < m &&
(c[nx][ny] == 'S' || c[nx][ny] == 'T' || G[c[nx][ny] - 'a'])) {
if (dist[nx][ny] == -1) {
dist[nx][ny] = dist[X][Y] + 1;
qx[eq] = nx;
qy[eq++] = ny;
}
}
}
}
}
int anslen = 1e9;
string ans;
bool vis[Maxn][Maxn];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%s", c[i]);
for (int j = 0; j < m; j++) {
if (c[i][j] == 'S') {
sx = i;
sy = j;
}
if (c[i][j] == 'T') {
ex = i;
ey = j;
}
}
}
dfs(0);
for (int i = 0; i < V.size(); i++) {
memset(G, 0, sizeof(G));
memset(vis, 0, sizeof(vis));
for (int j = 0; j < V[i].size(); j++) {
G[V[i][j]] = 1;
}
bfs(sx, sy, ds);
bfs(ex, ey, dt);
if (ds[ex][ey] == -1) continue;
string cur;
int dst = ds[ex][ey];
vector<pair<int, int> > Now, Nxt;
char cc = 'z' + 1;
Now.push_back(make_pair(sx, sy));
for (int j = 1; j < dst; j++) {
cc = 'z' + 1;
for (int t = 0; t < Now.size(); t++) {
int x = Now[t].first, y = Now[t].second;
for (int d = 0; d < 4; d++) {
int nx = x + dx[d], ny = y + dy[d];
if (nx >= 0 && ny >= 0 && nx < n && ny < m && !vis[nx][ny] &&
j + dt[nx][ny] == dst) {
vis[nx][ny] = 1;
char now = c[nx][ny];
if (now < cc) {
Nxt.clear();
cc = now;
}
if (now == cc) {
Nxt.push_back(make_pair(nx, ny));
}
}
}
}
cur += cc;
Now = Nxt;
Nxt.clear();
}
if (anslen > dst) {
anslen = dst;
ans = cur;
} else if (anslen == dst) {
if (cur < ans) ans = cur;
}
}
if (anslen == 1e9) {
printf("-1\n");
return 0;
}
printf("%s\n", ans.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string mat[50];
bool allow[26];
bool isAllow(char c) { return c == 'T' || c == 'S' || allow[c - 'a']; }
int di[] = {0, 0, 1, -1};
int dj[] = {1, -1, 0, 0};
int dist[50][50];
pair<int, int> pa[50][50];
int n, m;
bool in(int a, int b) { return 0 <= a && a < n && 0 <= b && b < m; }
void bfs(int x, int y) {
pair<int, int> orig = make_pair(x, y);
queue<pair<int, int> > cola;
memset(dist, -1, sizeof(dist));
int vis[n][m];
memset(vis, 0, sizeof(vis));
cola.push(orig);
vis[x][y] = true;
dist[x][y] = 0;
while (!cola.empty()) {
pair<int, int> cu = cola.front();
cola.pop();
int xx = cu.first, yy = cu.second;
for (int k = 0; k < 4; k++) {
int nx = xx + di[k], ny = yy + dj[k];
if (in(nx, ny) && isAllow(mat[nx][ny])) {
if (!vis[nx][ny]) {
dist[nx][ny] = dist[xx][yy] + 1;
pa[nx][ny] = cu;
vis[nx][ny] = true;
cola.push(make_pair(nx, ny));
} else if (dist[nx][ny] == dist[xx][yy] + 1) {
pair<int, int> p1 = cu, p2 = pa[nx][ny];
while (p1 != orig &&
mat[p1.first][p1.second] == mat[p2.first][p2.second]) {
p1 = pa[p1.first][p1.second];
p2 = pa[p2.first][p2.second];
}
if (p1 != orig &&
mat[p1.first][p1.second] < mat[p2.first][p2.second]) {
pa[nx][ny] = cu;
}
}
}
}
}
}
int main() {
int kk;
cin >> n >> m >> kk;
int xS, yS, xT, yT;
for (int i = 0; i < n; i++) {
cin >> mat[i];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (mat[i][j] == 'S') {
xS = i;
yS = j;
}
if (mat[i][j] == 'T') {
xT = i;
yT = j;
}
}
pair<int, int> final = make_pair(xT, yT);
string best;
int largo = 1000000000;
memset(allow, 0, sizeof(allow));
bool first = true;
for (int i = 0; i < 26; i++)
for (int j = i; j < 26; j++)
for (int k = j; k < 26; k++)
for (int h = k; h < 26; h++) {
if (kk < 4) h = i;
if (kk < 3) k = i;
if (kk < 2) j = i;
allow[i] = allow[j] = allow[k] = allow[h] = true;
bfs(xT, yT);
if (dist[xS][yS] != -1) {
int cu = dist[xS][yS];
if (cu <= largo) {
string curS = "";
pair<int, int> po = pa[xS][yS];
while (po != final) {
curS += mat[po.first][po.second];
po = pa[po.first][po.second];
}
if (cu < largo) {
largo = cu;
best = curS;
} else if (cu == largo && best > curS) {
best = curS;
}
}
}
allow[i] = allow[j] = allow[k] = allow[h] = false;
if (kk < 4) h = 26;
if (kk < 3) k = 26;
if (kk < 2) j = 26;
}
if (largo >= 1000000000)
cout << "-1" << endl;
else {
cout << best << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
int N, M, K;
int F[60][60], Q[3000][2];
int SX, SY, TX, TY;
string P[60][60];
pair<char, int> A[4];
string Ret;
char Map[60][60];
bool G[60][60], Choose[30];
inline void BFS() {
memset(G, false, sizeof(G));
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++)
if (Choose[Map[i][j] - 'a']) {
G[i][j] = true;
}
}
G[SX][SY] = true;
G[TX][TY] = true;
memset(F, -1, sizeof(F));
F[SX][SY] = 0;
int Head = 0, Tail = 1;
Q[1][0] = SX;
Q[1][1] = SY;
while (Head++ < Tail) {
int x = Q[Head][0];
int y = Q[Head][1];
if (x == TX && y == TY) {
break;
}
if (x != SX || y != SY) {
P[x][y] += Map[x][y];
}
for (int i = 0; i < 4; i++) {
int u = x + dx[i];
int v = y + dy[i];
if (!G[u][v]) {
continue;
}
if (F[u][v] == -1) {
F[u][v] = F[x][y] + 1;
P[u][v] = P[x][y];
Tail++;
Q[Tail][0] = u;
Q[Tail][1] = v;
} else if (F[x][y] + 1 == F[u][v] && P[x][y] < P[u][v]) {
P[u][v] = P[x][y];
}
}
}
if (F[TX][TY] == -1) {
return;
}
if (Ret != "-1" && F[TX][TY] > Ret.size() + 1) {
return;
}
string Ans = P[TX][TY];
if (Ret == "-1" || Ans.size() < Ret.size() || Ans < Ret) {
Ret = Ans;
}
}
inline void Search(int k, int total) {
if (total > K) {
return;
}
if (k == 26) {
if (total == K) {
BFS();
}
} else {
Choose[k] = true;
Search(k + 1, total + 1);
Choose[k] = false;
Search(k + 1, total);
}
}
int main(int argc, char *argv[]) {
scanf("%d%d%d", &N, &M, &K);
for (int i = 1; i <= N; i++) {
scanf("%s", Map[i] + 1);
for (int j = 1; j <= M; j++) {
if (Map[i][j] == 'S') {
SX = i;
SY = j;
Map[i][j] = 'a';
}
if (Map[i][j] == 'T') {
TX = i;
TY = j;
Map[i][j] = 'a';
}
}
}
Ret = "-1";
Search(0, 0);
cout << Ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {1, 0, -1, 0};
const int dy[5] = {0, 1, 0, -1};
string res = "";
int que[55 * 55][2], _que[55 * 55][2];
int dist[55][55];
bool p[55][55];
char g[55][55];
int n, m, limit;
int sx, sy, tx, ty;
bool flag[100];
int main() {
scanf("%d%d%d", &n, &m, &limit);
for (int i = 0; i < n; i++) scanf("%s", g[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] == 'S')
sx = i, sy = j;
else if (g[i][j] == 'T')
tx = i, ty = j;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] >= 'a' && g[i][j] <= 'z') flag[g[i][j] - 'a'] = 1;
flag[26] = 1;
if (abs(sx - tx) + abs(sy - ty) == 1) return 0;
for (int i = 0; i < 26; i++)
if (flag[i])
for (int j = i + 1; j < 27; j++)
if (flag[j]) {
if (j < 26 && limit == 1) continue;
for (int k = j; k < 27; k++)
if (flag[k]) {
if (k < 26 && limit == 2) continue;
if (k == j && k < 26) continue;
for (int l = k; l < 27; l++)
if (flag[l]) {
if (l < 26 && limit == 3) continue;
if (l == k && l < 26) continue;
int XXX = (1 << i) + (1 << j) + (1 << k) + (1 << l);
for (int a = 0; a < n; a++)
for (int b = 0; b < m; b++) dist[a][b] = -1, p[a][b] = 0;
dist[tx][ty] = 0;
que[0][0] = tx;
que[0][1] = ty;
int r = 0;
for (int l = 0; dist[sx][sy] == -1 && l <= r; l++) {
int u = que[l][0], v = que[l][1];
for (int w = 0; w < 4; w++)
if (u + dx[w] >= 0 && u + dx[w] < n && v + dy[w] >= 0 &&
v + dy[w] < m && dist[u + dx[w]][v + dy[w]] == -1) {
if (sx == u + dx[w] && sy == v + dy[w]) {
dist[sx][sy] = dist[u][v] + 1;
continue;
}
int uu = u + dx[w], vv = v + dy[w];
if (XXX & (1 << (g[uu][vv] - 'a'))) {
dist[uu][vv] = dist[u][v] + 1;
que[++r][0] = uu;
que[r][1] = vv;
}
}
}
if (dist[sx][sy] != -1) {
string tmp = "";
int r = 0;
que[0][0] = sx;
que[0][1] = sy;
while (tmp.size() != dist[sx][sy] - 1) {
char ww = 'z' + 1;
for (int l = 0; l <= r; l++) {
int u = que[l][0], v = que[l][1];
for (int w = 0; w < 4; w++) {
int uu = u + dx[w], vv = v + dy[w];
if (uu >= 0 && uu < n && vv >= 0 && vv < m &&
dist[uu][vv] != -1 &&
dist[uu][vv] + tmp.size() == dist[sx][sy] - 1)
ww = min(ww, g[uu][vv]);
}
}
int _r = -1;
for (int l = 0; l <= r; l++) {
int u = que[l][0], v = que[l][1];
for (int w = 0; w < 4; w++) {
int uu = u + dx[w], vv = v + dy[w];
if (uu >= 0 && uu < n && vv >= 0 && vv < m &&
!p[uu][vv] && dist[uu][vv] != -1 &&
dist[uu][vv] + tmp.size() == dist[sx][sy] - 1 &&
g[uu][vv] == ww) {
p[uu][vv] = 1;
_que[++_r][0] = uu;
_que[_r][1] = vv;
}
}
}
r = _r;
for (int l = 0; l <= r; l++)
que[l][0] = _que[l][0], que[l][1] = _que[l][1];
tmp += ww;
}
if (!res.size() || (res.size() > tmp.size()) ||
(res.size() == tmp.size() && res > tmp))
res = tmp;
}
}
}
}
if (!res.size())
printf("-1\n");
else
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int sx, sy, gy, gx;
vector<string> mat;
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
long long dis(int y1, int y2, int x2, int x1) {
return abs(y2 - y1) + abs(x2 - x1);
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
mat.push_back(str);
for (int j = 0; j < str.size(); j++) {
if (str[j] == 'S') {
sx = j;
sy = i;
}
if (str[j] == 'T') {
gx = j;
gy = i;
}
}
}
priority_queue<
pair<long long, pair<pair<string, long long>, long long> >,
vector<pair<long long, pair<pair<string, long long>, long long> > >,
greater<pair<long long, pair<pair<string, long long>, long long> > > >
pq;
pq.push(
make_pair(dis(gy, sy, gx, sx), make_pair(make_pair("", 0), sy * m + sx)));
set<pair<long long, long long> > ss;
while (!pq.empty()) {
int nt = pq.top().first;
string nstr = pq.top().second.first.first;
int nmask = pq.top().second.first.second;
int nx = pq.top().second.second % m;
int ny = pq.top().second.second / m;
int nn = pq.top().second.second;
pq.pop();
if (ss.count(make_pair(nn, nmask))) continue;
ss.insert(make_pair(nn, nmask));
for (int i = 0; i < 4; i++) {
int ax = nx + dx[i];
int ay = ny + dy[i];
if (ax < 0 || ax >= m || ay < 0 || ay >= n) continue;
if (ay == gy && ax == gx) {
cout << nstr << endl;
return 0;
}
string astr = nstr + mat[ay][ax];
int nnmask = nmask | (1 << (mat[ay][ax] - 'a'));
if (__builtin_popcount(nnmask) <= k) {
pq.push(make_pair(dis(ay, gy, ax, gx) + astr.size(),
make_pair(make_pair(astr, nnmask), ay * m + ax)));
}
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class MPI {
public:
vector<long long int> MPI_VALUE;
bool MPI_SIGN;
MPI(const string &mpi_s) {
MPI_SIGN = false;
if (((long long int)(mpi_s).size())) {
if (mpi_s[0] == '-') MPI_SIGN = true;
for (long long int i = ((long long int)(mpi_s).size()) - 1;
((mpi_s[0] == '-') ? 1 : 0) <= i; i -= 6) {
long long int mpi_sum = 0;
long long int mpi_base = 1;
for (long long int j = 0; j < ((long long int)(6)); j++)
if (((mpi_s[0] == '-') ? 1 : 0) <= i - j) {
mpi_sum += (mpi_s[i - j] - '0') * mpi_base;
mpi_base *= 10;
}
MPI_VALUE.push_back(mpi_sum);
}
}
mpi_reform(*this);
}
MPI(const vector<long long int> &mpi_vec) {
MPI_SIGN = false;
MPI_VALUE = mpi_vec;
mpi_reform(*this);
}
MPI(int mpi_val) {
MPI_SIGN = false;
if (mpi_val < 0) {
mpi_val = -mpi_val;
MPI_SIGN = true;
}
while (mpi_val) {
MPI_VALUE.push_back(mpi_val % 1000000);
mpi_val /= 1000000;
}
mpi_reform(*this);
}
MPI(long long int mpi_val) {
MPI_SIGN = false;
if (mpi_val < 0) {
mpi_val = -mpi_val;
MPI_SIGN = true;
}
while (mpi_val) {
MPI_VALUE.push_back(mpi_val % 1000000);
mpi_val /= 1000000;
}
mpi_reform(*this);
}
MPI(bool mpi_need0, bool mpi_need1) { MPI_SIGN = false; }
MPI() {
MPI_SIGN = false;
MPI_VALUE.push_back(0);
}
string to_string() const {
string mpi_res = "";
long long int mpi_p10[6 + 1];
for (long long int i = 0; i < ((long long int)(6 + 1)); i++)
mpi_p10[i] = (i) ? (mpi_p10[i - 1] * 10) : 1;
for (long long int i = ((long long int)(MPI_VALUE).size()) - 1; 0 <= i; i--)
for (long long int j = 0; j < ((long long int)(6)); j++) {
long long int mpi_tmp =
(MPI_VALUE[i] % mpi_p10[6 - j]) / mpi_p10[6 - j - 1];
if (((long long int)(mpi_res).size()) || mpi_tmp)
mpi_res += string(1, '0' + mpi_tmp);
}
if (((long long int)(mpi_res).size()) == 0)
mpi_res += "0";
else if (MPI_SIGN)
mpi_res = "-" + mpi_res;
return mpi_res;
}
long long int to_long() const {
long long int mpi_res = 0;
long long int mpi_base = 1;
for (long long int i = 0;
i < ((long long int)(((long long int)(MPI_VALUE).size()))); i++) {
mpi_res += MPI_VALUE[i] * mpi_base;
mpi_base *= 1000000;
}
if (MPI_SIGN) mpi_res = -mpi_res;
return mpi_res;
}
long long int size() const {
long long int mpi_res = (((long long int)(MPI_VALUE).size()) - 1) * 6;
long long int mpi_tmp = MPI_VALUE.back();
while (mpi_tmp) {
mpi_res++;
mpi_tmp /= 10;
}
return mpi_res;
}
static MPI mpi_abs_add(const MPI &mpi0, const MPI &mpi1) {
MPI mpi_res(false, false);
long long int carry = 0;
for (long long int i = 0;
i < ((long long int)(max(((long long int)(mpi0.MPI_VALUE).size()),
((long long int)(mpi1.MPI_VALUE).size()))));
i++) {
long long int mpi_t0 = (i < ((long long int)(mpi0.MPI_VALUE).size()))
? (mpi0.MPI_VALUE[i])
: 0;
long long int mpi_t1 = (i < ((long long int)(mpi1.MPI_VALUE).size()))
? (mpi1.MPI_VALUE[i])
: 0;
long long int mpi_t = mpi_t0 + mpi_t1 + carry;
mpi_res.MPI_VALUE.push_back(mpi_t % 1000000);
carry = mpi_t / 1000000;
}
if (carry) mpi_res.MPI_VALUE.push_back(carry);
mpi_reform(mpi_res);
return mpi_res;
}
static MPI mpi_abs_sub_sub(const MPI &mpi0, const MPI &mpi1) {
MPI mpi_res(false, false);
mpi_res.MPI_VALUE = mpi0.MPI_VALUE;
long long int carry = 0;
for (long long int i = 0;
i < ((long long int)(mpi1.MPI_VALUE).size()) || carry; i++) {
mpi_res.MPI_VALUE[i] -= carry;
carry = 0;
if (i < ((long long int)(mpi1.MPI_VALUE).size()))
mpi_res.MPI_VALUE[i] = mpi_res.MPI_VALUE[i] - mpi1.MPI_VALUE[i];
if (mpi_res.MPI_VALUE[i] < 0) {
carry++;
mpi_res.MPI_VALUE[i] += 1000000;
}
}
mpi_reform(mpi_res);
return mpi_res;
}
static MPI mpi_abs_sub(const MPI &mpi0, const MPI &mpi1) {
if (!mpi_abs_gt(mpi0, mpi1)) return mpi_abs_sub_sub(mpi0, mpi1);
MPI mpi_res = mpi_abs_sub_sub(mpi1, mpi0);
mpi_res.MPI_SIGN = !mpi_res.MPI_SIGN;
return mpi_res;
}
static MPI mpi_abs_mul(const MPI &mpi0, const MPI &mpi1) {
MPI mpi_res(false, false);
mpi_res.MPI_VALUE =
vector<long long int>(((long long int)(mpi0.MPI_VALUE).size()) +
((long long int)(mpi1.MPI_VALUE).size()),
0);
for (long long int i = 0;
i < ((long long int)(((long long int)(mpi0.MPI_VALUE).size()))); i++)
if (mpi0.MPI_VALUE[i]) {
for (long long int j = 0;
j < ((long long int)(((long long int)(mpi1.MPI_VALUE).size())));
j++) {
mpi_res.MPI_VALUE[i + j] += mpi0.MPI_VALUE[i] * mpi1.MPI_VALUE[j];
}
}
mpi_add_mul_reform(mpi_res);
return mpi_res;
}
MPI operator+(const MPI &mpi_var) const {
bool b0 = MPI_SIGN, b1 = mpi_var.MPI_SIGN;
if (!b0 && !b1) return mpi_abs_add(*this, mpi_var);
if (!b0 && b1) return mpi_abs_sub(*this, mpi_var);
if (b0 && !b1) return mpi_abs_sub(mpi_var, *this);
MPI mpi_res = mpi_abs_add(*this, mpi_var);
mpi_res.MPI_SIGN = !mpi_res.MPI_SIGN;
return mpi_res;
}
MPI operator-(const MPI &mpi_var) const {
bool b0 = MPI_SIGN, b1 = mpi_var.MPI_SIGN;
if (!b0 && !b1) return mpi_abs_sub(*this, mpi_var);
if (!b0 && b1) return mpi_abs_add(*this, mpi_var);
if (b0 && b1) return mpi_abs_sub(mpi_var, *this);
MPI mpi_res = mpi_abs_add(*this, mpi_var);
mpi_res.MPI_SIGN = !mpi_res.MPI_SIGN;
return mpi_res;
}
MPI operator*(const MPI &mpi_var) const {
bool b0 = MPI_SIGN, b1 = mpi_var.MPI_SIGN;
if (b0 && b1) return mpi_abs_mul(*this, mpi_var);
if (!b0 && !b1) return mpi_abs_mul(*this, mpi_var);
MPI mpi_res = mpi_abs_mul(*this, mpi_var);
mpi_res.MPI_SIGN = !mpi_res.MPI_SIGN;
return mpi_res;
}
friend std::ostream &operator<<(std::ostream &os, const MPI &mpi_var) {
os << mpi_var.to_string();
return os;
}
friend std::istream &operator>>(std::istream &is, MPI &mpi_var) {
string mpi_str;
is >> mpi_str;
mpi_var = MPI(mpi_str);
return is;
}
static void mpi_subst(MPI &mpi_from, const MPI &mpi_base,
long long int mpi_cons, long long int mpi_shift) {
long long int carry = 0;
for (long long int i = 0;
i + mpi_shift < ((long long int)(mpi_from.MPI_VALUE).size()); i++) {
mpi_from.MPI_VALUE[mpi_shift + i] -= carry;
carry = 0;
if (i < ((long long int)(mpi_base.MPI_VALUE).size())) {
carry = (mpi_base.MPI_VALUE[i] * mpi_cons) / 1000000;
mpi_from.MPI_VALUE[mpi_shift + i] -=
(mpi_base.MPI_VALUE[i] * mpi_cons) % 1000000;
}
while (mpi_from.MPI_VALUE[mpi_shift + i] < 0) {
carry++;
mpi_from.MPI_VALUE[mpi_shift + i] += 1000000;
}
}
}
static bool mpi_can_sub(const MPI &mpi_from, const MPI &mpi_base,
long long int mpi_cons, long long int mpi_shift) {
long long int carry = 0;
for (long long int i = 0;
i + mpi_shift < ((long long int)(mpi_from.MPI_VALUE).size()); i++) {
long long int mpi_tmp = carry;
if (i < ((long long int)(mpi_base.MPI_VALUE).size()))
mpi_tmp += mpi_base.MPI_VALUE[i] * mpi_cons;
long long int mpi_dif = (mpi_tmp - mpi_from.MPI_VALUE[i + mpi_shift]);
if (mpi_dif < 0)
carry = 0;
else
carry = ((mpi_dif % 1000000) ? 1 : 0) + mpi_dif / 1000000;
}
return carry == 0;
}
static MPI mpi_abs_div_small(const MPI &mpi_den, const MPI &mpi_num,
bool is_div) {
MPI mpi_ans(false, false);
MPI mpi_rem(mpi_den.MPI_VALUE);
mpi_ans.MPI_VALUE =
vector<long long int>(((long long int)(mpi_rem.MPI_VALUE).size()), 0);
long long int mpi_cons = abs(mpi_num.to_long()), carry = 0;
for (long long int i = ((long long int)(mpi_rem.MPI_VALUE).size()) - 1;
0 <= i; i--) {
mpi_rem.MPI_VALUE[i] += carry * 1000000;
carry = mpi_rem.MPI_VALUE[i] % mpi_cons;
mpi_ans.MPI_VALUE[i] = mpi_rem.MPI_VALUE[i] / mpi_cons;
}
if (!is_div) return MPI(carry);
mpi_reform(mpi_ans);
return mpi_ans;
}
static MPI mpi_abs_div(const MPI &mpi_den, const MPI &mpi_num, bool is_div) {
if (mpi_abs_gt(mpi_num, 1000000))
return mpi_abs_div_small(mpi_den, mpi_num, is_div);
MPI mpi_ans(0);
MPI mpi_rem(mpi_den.MPI_VALUE);
mpi_ans.MPI_VALUE =
vector<long long int>(((long long int)(mpi_rem.MPI_VALUE).size()), 0);
long long int mpi_num_pos = ((long long int)(mpi_num.MPI_VALUE).size()) - 1;
long long int mpi_num_n = mpi_num.MPI_VALUE[mpi_num_pos];
if (mpi_num_n * 1000000 < 1000000000000000000ll / 1000000 &&
1 <= mpi_num_pos) {
mpi_num_n = mpi_num_n * 1000000 + mpi_num.MPI_VALUE[--mpi_num_pos];
}
while (!mpi_abs_gt(mpi_rem, mpi_num)) {
long long int mpi_rem_pos =
((long long int)(mpi_rem.MPI_VALUE).size()) - 1;
long long int mpi_rem_n = mpi_rem.MPI_VALUE[mpi_rem_pos];
while (mpi_rem_n < mpi_num_n) {
mpi_rem_n = mpi_rem_n * 1000000 + mpi_rem.MPI_VALUE[--mpi_rem_pos];
}
long long int mpi_tmp = mpi_rem_n / mpi_num_n;
long long int mpi_dif = mpi_rem_pos - mpi_num_pos;
while (!mpi_can_sub(mpi_rem, mpi_num, mpi_tmp, mpi_dif)) mpi_tmp--;
if (mpi_tmp == 0) {
mpi_rem_n = mpi_rem_n * 1000000 + mpi_rem.MPI_VALUE[--mpi_rem_pos];
mpi_tmp = mpi_rem_n / mpi_num_n;
mpi_dif = mpi_rem_pos - mpi_num_pos;
while (!mpi_can_sub(mpi_rem, mpi_num, mpi_tmp, mpi_dif)) mpi_tmp--;
}
mpi_subst(mpi_rem, mpi_num, mpi_tmp, mpi_dif);
mpi_ans.MPI_VALUE[mpi_dif] += mpi_tmp;
mpi_reform(mpi_rem);
}
if (!is_div) return mpi_rem;
mpi_add_mul_reform(mpi_ans);
return mpi_ans;
}
MPI operator/(const MPI &mpi_var) const {
bool b0 = MPI_SIGN, b1 = mpi_var.MPI_SIGN;
if (!b0 && !b1) return mpi_abs_div(*this, mpi_var, true);
if (b0 && b1) return mpi_abs_div(*this, mpi_var, true);
MPI mpi_res = mpi_abs_div(*this, mpi_var, true);
mpi_res.MPI_SIGN = !mpi_res.MPI_SIGN;
return mpi_res;
}
MPI operator%(const MPI &mpi_var) const {
bool b0 = MPI_SIGN;
if (!b0) return mpi_abs_div(*this, mpi_var, false);
MPI mpi_res = mpi_abs_div(*this, mpi_var, false);
mpi_res.MPI_SIGN = !mpi_res.MPI_SIGN;
return mpi_res;
}
bool operator<(const MPI &mpi_var) const {
bool b0 = MPI_SIGN, b1 = mpi_var.MPI_SIGN;
if (!b0 && !b1) return mpi_abs_gt(*this, mpi_var);
if (b0 && b1) return mpi_abs_sl(*this, mpi_var);
if (((long long int)(this->MPI_VALUE).size()) == 1 &&
((long long int)(mpi_var.MPI_VALUE).size()) == 1) {
if (this->MPI_VALUE.back() == 0 && mpi_var.MPI_VALUE.back() == 0)
return true;
}
if (b0 && !b1) return true;
if (!b0 && b1) return false;
}
bool operator>(const MPI &mpi_var) const {
bool b0 = MPI_SIGN, b1 = mpi_var.MPI_SIGN;
if (!b0 && !b1) return mpi_abs_sl(*this, mpi_var);
if (b0 && b1) return mpi_abs_gt(*this, mpi_var);
if (((long long int)(this->MPI_VALUE).size()) == 1 &&
((long long int)(mpi_var.MPI_VALUE).size()) == 1) {
if (this->MPI_VALUE.back() == 0 && mpi_var.MPI_VALUE.back() == 0)
return true;
}
if (b0 && !b1) return false;
if (!b0 && b1) return true;
}
bool operator==(const MPI &mpi_var) const {
bool b0 = MPI_SIGN, b1 = mpi_var.MPI_SIGN;
if (b0 && b1) return mpi_abs_eq(*this, mpi_var);
if (!b0 && !b1) return mpi_abs_eq(*this, mpi_var);
if (((long long int)(this->MPI_VALUE).size()) == 1 &&
((long long int)(mpi_var.MPI_VALUE).size()) == 1) {
if (this->MPI_VALUE.back() == 0 && mpi_var.MPI_VALUE.back() == 0)
return true;
}
return false;
}
bool operator>=(const MPI &mpi_var) const { return !(*this < mpi_var); }
bool operator<=(const MPI &mpi_var) const { return !(*this > mpi_var); }
bool operator!=(const MPI &mpi_var) const { return !(*this == mpi_var); }
void operator+=(const MPI &mpi_var) { *this = *this + mpi_var; }
void operator-=(const MPI &mpi_var) { *this = *this - mpi_var; }
void operator*=(const MPI &mpi_var) { *this = *this * mpi_var; }
void operator/=(const MPI &mpi_var) { *this = *this / mpi_var; }
void operator%=(const MPI &mpi_var) { *this = *this % mpi_var; }
friend bool operator>(long long int mpi_li, const MPI &mpi_var) {
return MPI(mpi_li) > mpi_var;
}
friend bool operator<(long long int mpi_li, const MPI &mpi_var) {
return MPI(mpi_li) < mpi_var;
}
friend bool operator>=(long long int mpi_li, const MPI &mpi_var) {
return MPI(mpi_li) >= mpi_var;
}
friend bool operator<=(long long int mpi_li, const MPI &mpi_var) {
return MPI(mpi_li) <= mpi_var;
}
friend bool operator!=(long long int mpi_li, const MPI &mpi_var) {
return MPI(mpi_li) != mpi_var;
}
friend bool operator==(long long int mpi_li, const MPI &mpi_var) {
return MPI(mpi_li) == mpi_var;
}
MPI operator--() {
*this = *this - MPI(1);
return *this;
}
MPI operator++() {
*this = *this + MPI(1);
return *this;
}
MPI operator++(int mpi_i) {
MPI mpi_res = *this;
*this = *this + MPI(1);
return mpi_res;
}
MPI operator--(int mpi_i) {
MPI mpi_res = *this;
*this = *this - MPI(1);
return mpi_res;
}
MPI operator-() {
MPI mpi_res = *this;
mpi_res.MPI_SIGN = !mpi_res.MPI_SIGN;
return mpi_res;
}
static bool mpi_abs_gt(const MPI &mpi0, const MPI &mpi1) {
if (((long long int)(mpi0.MPI_VALUE).size()) ==
((long long int)(mpi1.MPI_VALUE).size())) {
for (long long int i = ((long long int)(mpi0.MPI_VALUE).size()) - 1;
0 <= i; i--) {
if (mpi0.MPI_VALUE[i] != mpi1.MPI_VALUE[i]) {
return mpi0.MPI_VALUE[i] < mpi1.MPI_VALUE[i];
}
}
}
return ((long long int)(mpi0.MPI_VALUE).size()) <
((long long int)(mpi1.MPI_VALUE).size());
}
static bool mpi_abs_sl(const MPI &mpi0, const MPI &mpi1) {
if (((long long int)(mpi0.MPI_VALUE).size()) ==
((long long int)(mpi1.MPI_VALUE).size())) {
for (long long int i = ((long long int)(mpi0.MPI_VALUE).size()) - 1;
0 <= i; i--) {
if (mpi0.MPI_VALUE[i] != mpi1.MPI_VALUE[i]) {
return mpi0.MPI_VALUE[i] > mpi1.MPI_VALUE[i];
}
}
}
return ((long long int)(mpi0.MPI_VALUE).size()) >
((long long int)(mpi1.MPI_VALUE).size());
}
static bool mpi_abs_eq(const MPI &mpi0, const MPI &mpi1) {
if (((long long int)(mpi0.MPI_VALUE).size()) !=
((long long int)(mpi1.MPI_VALUE).size()))
return false;
for (long long int i = 0;
i < ((long long int)(((long long int)(mpi0.MPI_VALUE).size()))); i++) {
if (mpi0.MPI_VALUE[i] != mpi1.MPI_VALUE[i]) return false;
}
return true;
}
private:
static void mpi_reform_vec(vector<long long int> &mpi_vec) {
if (((long long int)(mpi_vec).size()) == 0) mpi_vec.push_back(0);
while (1 < ((long long int)(mpi_vec).size()) && mpi_vec.back() == 0)
mpi_vec.pop_back();
}
static void mpi_add_mul_reform_vec(vector<long long int> &mpi_vec) {
long long int carry = 0;
for (long long int i = 0;
i < ((long long int)(((long long int)(mpi_vec).size()))); i++) {
mpi_vec[i] += carry;
carry = mpi_vec[i] / 1000000;
mpi_vec[i] %= 1000000;
}
mpi_vec.push_back(carry);
mpi_reform_vec(mpi_vec);
}
static void mpi_reform(MPI &mpi_var) {
mpi_reform_vec(mpi_var.MPI_VALUE);
if (((long long int)(mpi_var.MPI_VALUE).size()) == 1 &&
mpi_var.MPI_VALUE[0] == 0)
mpi_var.MPI_SIGN = false;
}
static void mpi_add_mul_reform(MPI &mpi_var) {
mpi_add_mul_reform_vec(mpi_var.MPI_VALUE);
if (((long long int)(mpi_var.MPI_VALUE).size()) == 1 &&
mpi_var.MPI_VALUE[0] == 0)
mpi_var.MPI_SIGN = false;
}
};
class IRN {
public:
MPI IRN_DEN;
MPI IRN_NUM;
bool IRN_SIGN;
IRN() {
IRN_DEN = 0;
IRN_NUM = 1;
IRN_SIGN = false;
}
IRN(string irn_str0, string irn_str1) {
IRN_DEN = irn_str0;
IRN_NUM = irn_str1;
IRN_SIGN = false;
if (IRN_DEN < 0) IRN_SIGN = !IRN_SIGN;
if (IRN_NUM < 0) IRN_SIGN = !IRN_SIGN;
IRN_DEN.MPI_SIGN = false;
IRN_NUM.MPI_SIGN = false;
irn_reduct(*this);
}
IRN(long long int irn_li0, long long int irn_li1) {
IRN_DEN = irn_li0;
IRN_NUM = irn_li1;
IRN_SIGN = false;
if (IRN_DEN < 0) IRN_SIGN = !IRN_SIGN;
if (IRN_NUM < 0) IRN_SIGN = !IRN_SIGN;
IRN_DEN.MPI_SIGN = false;
IRN_NUM.MPI_SIGN = false;
irn_reduct(*this);
}
IRN(long long int irn_li) {
IRN_DEN = irn_li;
IRN_NUM = 1;
IRN_SIGN = false;
}
IRN(string irn_str) {
IRN_DEN = irn_str;
IRN_NUM = 1;
IRN_SIGN = false;
}
string to_string() const {
if (IRN_SIGN && IRN_DEN != 0)
return "-" + IRN_DEN.to_string() + "/" + IRN_NUM.to_string();
return IRN_DEN.to_string() + "/" + IRN_NUM.to_string();
}
static MPI irn_mpi_gcd(MPI mpi0, MPI mpi1) {
MPI mpi_res = 1;
if (mpi0 == 0 || mpi1 == 0) return MPI(1);
for (MPI i = 2; i * i <= min(mpi0, mpi1); i++) {
while (true) {
if (mpi0 % i != 0) break;
if (mpi1 % i != 0) break;
mpi0 /= i;
mpi1 /= i;
mpi_res *= i;
}
while (mpi0 % i == 0) mpi0 /= i;
while (mpi1 % i == 0) mpi1 /= i;
}
if (mpi0 % min(mpi0, mpi1) != 0) return mpi_res;
if (mpi1 % min(mpi0, mpi1) != 0) return mpi_res;
return mpi_res * min(mpi0, mpi1);
}
void irn_reduct(IRN &irn_var) const {
if (irn_var.IRN_DEN == 0) {
irn_var.IRN_NUM = 1;
irn_var.IRN_SIGN = false;
return;
}
if (irn_var.IRN_DEN.MPI_SIGN) irn_var.IRN_SIGN = !irn_var.IRN_SIGN;
if (irn_var.IRN_NUM.MPI_SIGN) irn_var.IRN_SIGN = !irn_var.IRN_SIGN;
irn_var.IRN_DEN.MPI_SIGN = false;
irn_var.IRN_NUM.MPI_SIGN = false;
MPI irn_t = irn_mpi_gcd(irn_var.IRN_NUM, irn_var.IRN_DEN);
irn_var.IRN_NUM /= irn_t;
irn_var.IRN_DEN /= irn_t;
}
IRN irn_mul(const IRN &irn0, const IRN &irn1) const {
IRN irn_res(1, 1);
MPI irn_t = irn_mpi_gcd(irn0.IRN_DEN, irn1.IRN_NUM);
irn_res.IRN_DEN = irn0.IRN_DEN / irn_t;
irn_res.IRN_NUM = irn1.IRN_NUM / irn_t;
irn_t = irn_mpi_gcd(irn0.IRN_NUM, irn1.IRN_DEN);
irn_res.IRN_DEN *= irn1.IRN_DEN / irn_t;
irn_res.IRN_NUM *= irn0.IRN_NUM / irn_t;
if (irn1.IRN_SIGN) irn_res.IRN_SIGN = !irn_res.IRN_SIGN;
if (irn0.IRN_SIGN) irn_res.IRN_SIGN = !irn_res.IRN_SIGN;
if (irn_res.IRN_DEN == 0) {
irn_res.IRN_NUM = 1;
irn_res.IRN_SIGN = false;
}
return irn_res;
}
IRN irn_div(const IRN &irn0, const IRN &irn1) const {
IRN irn_res(1, 1);
MPI irn_t = irn_mpi_gcd(irn0.IRN_DEN, irn1.IRN_DEN);
irn_res.IRN_DEN = irn0.IRN_DEN / irn_t;
irn_res.IRN_NUM = irn1.IRN_DEN / irn_t;
irn_t = irn_mpi_gcd(irn0.IRN_NUM, irn1.IRN_NUM);
irn_res.IRN_DEN *= irn1.IRN_NUM / irn_t;
irn_res.IRN_NUM *= irn0.IRN_NUM / irn_t;
if (irn1.IRN_SIGN) irn_res.IRN_SIGN = !irn_res.IRN_SIGN;
if (irn0.IRN_SIGN) irn_res.IRN_SIGN = !irn_res.IRN_SIGN;
if (irn_res.IRN_DEN == 0) {
irn_res.IRN_NUM = 1;
irn_res.IRN_SIGN = false;
}
return irn_res;
}
IRN irn_abs_add(const IRN &irn0, const IRN &irn1) const {
IRN irn_res(0);
if (irn0.IRN_NUM == irn1.IRN_NUM) {
irn_res.IRN_DEN = irn0.IRN_DEN + irn1.IRN_DEN;
irn_res.IRN_NUM = irn0.IRN_NUM;
irn_reduct(irn_res);
return irn_res;
}
irn_res.IRN_NUM = irn0.IRN_NUM * irn1.IRN_NUM;
irn_res.IRN_DEN = irn0.IRN_DEN * irn1.IRN_NUM;
irn_res.IRN_DEN += irn1.IRN_DEN * irn0.IRN_NUM;
irn_reduct(irn_res);
return irn_res;
}
IRN irn_abs_sub(const IRN &irn0, const IRN &irn1) const {
IRN irn_res(0);
if (irn0.IRN_NUM == irn1.IRN_NUM) {
irn_res.IRN_DEN = irn0.IRN_DEN - irn1.IRN_DEN;
irn_res.IRN_NUM = irn0.IRN_NUM;
irn_reduct(irn_res);
return irn_res;
}
irn_res.IRN_NUM = irn0.IRN_NUM * irn1.IRN_NUM;
irn_res.IRN_DEN = irn0.IRN_DEN * irn1.IRN_NUM;
irn_res.IRN_DEN -= irn1.IRN_DEN * irn0.IRN_NUM;
irn_reduct(irn_res);
return irn_res;
}
IRN irn_add(const IRN &irn0, const IRN &irn1) const {
if (irn0.IRN_SIGN && irn1.IRN_SIGN) {
IRN irn_res = irn_abs_add(irn0, irn1);
irn_res.IRN_SIGN = !irn_res.IRN_SIGN;
return irn_res;
}
if (!irn0.IRN_SIGN && !irn1.IRN_SIGN) return irn_abs_add(irn0, irn1);
IRN irn_res;
if (!irn0.IRN_SIGN && irn1.IRN_SIGN) irn_res = irn_abs_sub(irn0, irn1);
if (irn0.IRN_SIGN && !irn1.IRN_SIGN) irn_res = irn_abs_sub(irn1, irn0);
if (irn_res.IRN_DEN.MPI_SIGN) {
irn_res.IRN_DEN.MPI_SIGN = false;
irn_res.IRN_SIGN = true;
}
return irn_res;
}
IRN irn_sub(const IRN &irn0, const IRN &irn1) const {
if (!irn0.IRN_SIGN && irn1.IRN_SIGN) return irn_abs_add(irn0, irn1);
if (irn0.IRN_SIGN && !irn1.IRN_SIGN) {
IRN irn_res = irn_abs_add(irn0, irn1);
irn_res.IRN_SIGN = !irn_res.IRN_SIGN;
return irn_res;
}
IRN irn_res;
if (irn0.IRN_SIGN && irn1.IRN_SIGN) {
irn_res = irn_abs_sub(irn0, irn1);
irn_res.IRN_SIGN = !irn_res.IRN_SIGN;
}
if (!irn0.IRN_SIGN && !irn1.IRN_SIGN) {
irn_res = irn_abs_sub(irn0, irn1);
}
if (irn_res.IRN_DEN.MPI_SIGN) {
irn_res.IRN_DEN.MPI_SIGN = false;
irn_res.IRN_SIGN = true;
}
return irn_res;
}
bool operator<(const IRN &irn_var) const {
if (this->IRN_DEN == 0 && irn_var.IRN_DEN == 0) return false;
bool b0 = this->IRN_SIGN, b1 = irn_var.IRN_SIGN;
if (b0 && !b1) return true;
if (!b1 && b0) return false;
MPI left = this->IRN_DEN * irn_var.IRN_NUM;
MPI right = irn_var.IRN_DEN * this->IRN_NUM;
if (!b0 && !b1) return left < right;
return right < left;
}
bool operator>(const IRN &irn_var) const {
if (this->IRN_DEN == 0 && irn_var.IRN_DEN == 0) return false;
bool b0 = this->IRN_SIGN, b1 = irn_var.IRN_SIGN;
if (b0 && !b1) return false;
if (!b0 && b1) return true;
MPI left = this->IRN_DEN * irn_var.IRN_NUM;
MPI right = irn_var.IRN_DEN * this->IRN_NUM;
if (!b0 && !b1) return left > right;
return right < left;
}
bool operator==(const IRN &irn_var) const {
if (this->IRN_DEN == 0 && irn_var.IRN_DEN == 0) return true;
if (this->IRN_SIGN && !irn_var.IRN_SIGN) return false;
if (!this->IRN_SIGN && irn_var.IRN_SIGN) return false;
return this->IRN_DEN == irn_var.IRN_DEN && this->IRN_NUM == irn_var.IRN_NUM;
}
IRN operator+(const IRN &irn_var) const { return irn_add(*this, irn_var); }
IRN operator-(const IRN &irn_var) const { return irn_sub(*this, irn_var); }
IRN operator/(const IRN &irn_var) const { return irn_div(*this, irn_var); }
IRN operator*(const IRN &irn_var) const { return irn_mul(*this, irn_var); }
void operator+=(const IRN &irn_var) { *this = *this + irn_var; }
void operator-=(const IRN &irn_var) { *this = *this - irn_var; }
void operator*=(const IRN &irn_var) { *this = *this * irn_var; }
void operator/=(const IRN &irn_var) { *this = *this / irn_var; }
IRN operator<=(const IRN &irn_var) const { return !(irn_var < *this); }
IRN operator>=(const IRN &irn_var) const { return !(*this < irn_var); }
IRN operator!=(const IRN &irn_var) const { return !(*this == irn_var); }
friend std::ostream &operator<<(std::ostream &os, const IRN &irn_var) {
os << irn_var.to_string();
return os;
}
private:
};
string mp[55];
long long int dx[] = {1, 0, -1, 0};
long long int dy[] = {0, 1, 0, -1};
int main() {
long long int n, m, k, sx, sy, gx, gy;
cin >> n >> m >> k;
for (long long int i = 0; i < ((long long int)(n)); i++) cin >> mp[i];
for (long long int i = 0; i < ((long long int)(n)); i++)
for (long long int j = 0; j < ((long long int)(m)); j++)
if (mp[i][j] == 'S') sx = i, sy = j;
for (long long int i = 0; i < ((long long int)(n)); i++)
for (long long int j = 0; j < ((long long int)(m)); j++)
if (mp[i][j] == 'T') gx = i, gy = j;
set<pair<long long int, pair<long long int, long long int> > > used;
priority_queue<
pair<pair<long long int, string>,
pair<long long int, pair<long long int, long long int> > >,
vector<pair<pair<long long int, string>,
pair<long long int, pair<long long int, long long int> > > >,
greater<
pair<pair<long long int, string>,
pair<long long int, pair<long long int, long long int> > > > >
q;
q.push(make_pair(make_pair(0, ""), make_pair(0, make_pair(sx, sy))));
while (((long long int)(q).size())) {
long long int mask = q.top().second.first;
long long int x = q.top().second.second.first;
long long int y = q.top().second.second.second;
string str = q.top().first.second;
q.pop();
bool ok = true;
{
long long int tmp = mask;
do {
if (used.find(make_pair(tmp, make_pair(x, y))) != used.end())
ok = false;
tmp = (tmp - 1) & mask;
} while (ok && tmp != mask);
}
if (!ok) continue;
used.insert(make_pair(mask, make_pair(x, y)));
for (long long int i = 0; i < ((long long int)(4)); i++) {
long long int xx = x + dx[i];
long long int yy = y + dy[i];
if (xx < 0 || n <= xx || yy < 0 || m <= yy) continue;
if (mp[xx][yy] == 'T') {
cout << str << endl;
return 0;
}
if (mp[xx][yy] == 'S') continue;
string next = str + string(1, mp[xx][yy]);
long long int nmask = mask | (1ll << (long long int)(mp[xx][yy] - 'a'));
if (k < __builtin_popcountll(nmask)) continue;
q.push(make_pair(make_pair(((long long int)(next).size()), next),
make_pair(nmask, make_pair(xx, yy))));
}
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
void fill_(S& buf, T x) {
fill(reinterpret_cast<T*>(&buf),
reinterpret_cast<T*>(&buf) + sizeof(buf) / sizeof(T), x);
}
template <typename T, int N>
inline int countof(const T (&)[N]) {
return N;
}
template <typename T>
inline vector<T>& operator+=(vector<T>& ret, const T& x) {
ret.push_back(x);
return ret;
}
int begin___ = 0, end___ = 0;
int fifo___[(1000000)];
int originalBoard[(50) + 8][(50) + 8];
int board[(50) + 8][(50) + 8];
int distances[(50) + 8][(50) + 8];
int H, W, K;
int best = (INT_MAX);
int dys[] = {-1, 0, 0, 1};
int dxs[] = {0, -1, 1, 0};
int y0_, x0_, ye_, xe_;
vector<vector<int>> cxs, cys;
string ret;
bool find_pos(int& y, int& x, const int c) {
for (int i = int(0), CNT_i = int(H); i < CNT_i; ++i)
for (int j = int(0), CNT_j = int(W); j < CNT_j; ++j)
if (originalBoard[i][j] == c) {
y = i;
x = j;
return true;
}
return false;
}
inline bool in_range(const int y, const int x) {
return 0 <= y && y < H && 0 <= x && x < W && board[y][x] != '#';
}
bool bfs() {
fill_(distances, (INT_MAX));
(begin___ = end___ = 0);
(fifo___[end___++] =
(((((0) & 0x3FFF) << 18) | (((ye_)&0x1FF) << 9) | ((xe_)&0x1FF))));
while (!(begin___ == end___)) {
int S_cyx = ((fifo___[begin___++])), c = ((S_cyx) >> 18 & 0x3FFF),
y = ((S_cyx) >> 9 & 0x1FF), x = ((S_cyx)&0x1FF);
;
if (distances[y][x] != (INT_MAX)) continue;
distances[y][x] = c;
if (y == y0_ && x == x0_) continue;
for (int i = int(0), CNT_i = int(countof(dys)); i < CNT_i; ++i) {
const int y_ = y + dys[i], x_ = x + dxs[i];
if (!in_range(y_, x_)) continue;
(fifo___[end___++] =
(((((c + 1) & 0x3FFF) << 18) | (((y_)&0x1FF) << 9) | ((x_)&0x1FF))));
}
}
return distances[y0_][x0_] != (INT_MAX);
}
void route() {
const int d = distances[y0_][x0_];
if (d > best) {
return;
} else {
string r;
assert(d != (INT_MAX));
vector<int> xs;
r.clear();
(begin___ = end___ = 0);
(fifo___[end___++] =
((((('S') & 0x3FFF) << 18) | (((y0_)&0x1FF) << 9) | ((x0_)&0x1FF))));
for (int n = d - 1; n > 0; --n) {
xs.clear();
while (!(begin___ == end___)) {
int S_cyx = ((fifo___[begin___++])), c = ((S_cyx) >> 18 & 0x3FFF),
y = ((S_cyx) >> 9 & 0x1FF), x = ((S_cyx)&0x1FF);
;
for (int i = int(0), CNT_i = int(countof(dys)); i < CNT_i; ++i) {
const int y_ = y + dys[i], x_ = x + dxs[i];
if (!in_range(y_, x_) || distances[y_][x_] != n) continue;
xs += ((((board[y_][x_]) & 0x3FFF) << 18) | (((y_)&0x1FF) << 9) |
((x_)&0x1FF));
}
}
(begin___ = end___ = 0);
sort((xs).begin(), (xs).end());
const int L = unique((xs).begin(), (xs).end()) - xs.begin();
int S_cy_x_ = (xs[0]), c_ = ((S_cy_x_) >> 18 & 0x3FFF),
y_ = ((S_cy_x_) >> 9 & 0x1FF), x_ = ((S_cy_x_)&0x1FF);
;
for (int i = int(0), CNT_i = int(L); i < CNT_i; ++i) {
if (((xs[i]) >> 18 & 0x3FFF) == c_)
(fifo___[end___++] = (xs[i]));
else
break;
}
r += c_;
};
if (d < best) {
best = d;
ret = r;
} else {
ret = min(ret, r);
}
}
}
void dfs(const int k, int next) {
if (k == 0) {
if (bfs()) route();
} else {
for (int c = next; c <= int('z'); ++c) {
const vector<int>(&ys) = cys[c], (&xs) = cxs[c];
for (int i = int(0), CNT_i = int(int((ys).size())); i < CNT_i; ++i)
board[ys[i]][xs[i]] = c;
dfs(k - 1, c + 1);
for (int i = int(0), CNT_i = int(int((ys).size())); i < CNT_i; ++i)
board[ys[i]][xs[i]] = '#';
}
}
}
void init() {
find_pos(y0_, x0_, 'S');
find_pos(ye_, xe_, 'T');
fill_(board, int('#'));
board[y0_][x0_] = 'S';
board[ye_][xe_] = 'T';
fill_(distances, (INT_MAX));
cys.assign(int('z') + 10, vector<int>());
cxs.assign(int('z') + 10, vector<int>());
for (int i = int(0), CNT_i = int(H); i < CNT_i; ++i)
for (int j = int(0), CNT_j = int(W); j < CNT_j; ++j) {
cys[originalBoard[i][j]] += i;
cxs[originalBoard[i][j]] += j;
}
}
int main(int argc, char* argv[]) {
string s;
cin >> H >> W >> K;
for (int i = int(0), CNT_i = int(H); i < CNT_i; ++i) {
cin >> s;
for (int j = int(0), CNT_j = int(int((s).size())); j < CNT_j; ++j)
originalBoard[i][j] = s[j];
}
init();
dfs(K, 'a');
if (best == (INT_MAX))
cout << -1 << endl;
else
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int k;
char str[55][55];
int sr, sc;
int er, ec;
string cur;
bool can[26];
int am = 0;
int mark[55][55];
int dist[55][55];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int qhead, qtail;
int q[55 * 55 * 4];
int nqtail;
int nq[55 * 55 * 4];
int go(int r, int c) {
qhead = qtail = 0;
mark[r][c] = am;
dist[r][c] = 0;
q[qtail++] = r;
q[qtail++] = c;
while (qhead < qtail) {
int cr = q[qhead++];
int cc = q[qhead++];
if (str[cr][cc] == 'S') return dist[cr][cc];
for (int dir = 0; dir < 4; ++dir) {
int nr = cr + dx[dir];
int nc = cc + dy[dir];
if (nr < 0 || nr >= n || nc < 0 || nc >= m) continue;
if (mark[nr][nc] == am) continue;
if (str[nr][nc] != 'S' && (str[nr][nc] == 'T' || !can[str[nr][nc] - 'a']))
continue;
mark[nr][nc] = am;
dist[nr][nc] = dist[cr][cc] + 1;
q[qtail++] = nr;
q[qtail++] = nc;
}
}
return 987654321;
}
void rec(int r, int c) {
qhead = qtail = 0;
nqtail = 0;
q[qtail++] = r;
q[qtail++] = c;
mark[r][c] = am;
cur = "";
for (int stp = 0; stp < dist[r][c] - 1; ++stp) {
int best = 255;
for (int i = 0; i < qtail; i += 2) {
int cr = q[i];
int cc = q[i + 1];
for (int dir = 0; dir < 4; ++dir) {
int nr = cr + dx[dir];
int nc = cc + dy[dir];
if (mark[nr][nc] == am) continue;
if (nr < 0 || nr >= n || nc < 0 || nc >= m) continue;
if (dist[nr][nc] != dist[cr][cc] - 1) continue;
if (str[nr][nc] != 'T' &&
(str[nr][nc] == 'S' || !can[str[nr][nc] - 'a']))
continue;
best = min(best, (int)str[nr][nc]);
}
}
cur += char(best);
for (int i = 0; i < qtail; i += 2) {
int cr = q[i];
int cc = q[i + 1];
for (int dir = 0; dir < 4; ++dir) {
int nr = cr + dx[dir];
int nc = cc + dy[dir];
if (mark[nr][nc] == am) continue;
if (nr < 0 || nr >= n || nc < 0 || nc >= m) continue;
if (dist[nr][nc] != dist[cr][cc] - 1) continue;
if (str[nr][nc] != 'T' &&
(str[nr][nc] == 'S' || !can[str[nr][nc] - 'a']))
continue;
if (best == str[nr][nc]) {
mark[nr][nc] = am;
nq[nqtail++] = nr;
nq[nqtail++] = nc;
}
}
}
for (int i = 0; i < nqtail; ++i) {
q[i] = nq[i];
}
qtail = nqtail;
nqtail = 0;
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
cin >> str[i];
for (int j = 0; j < m; ++j)
if (str[i][j] == 'S') {
sr = i;
sc = j;
} else if (str[i][j] == 'T') {
er = i;
ec = j;
}
}
int dist = 987654321;
string res = "";
memset(can, 0, sizeof(can));
memset(mark, -1, sizeof(mark));
for (int a = 0; a < 26; ++a) {
for (int b = a; b < 26; ++b) {
for (int c = b; c < 26; ++c) {
for (int d = c; d < 26; ++d) {
int cnt = 1;
if (b != a) ++cnt;
if (c != b) ++cnt;
if (d != c) ++cnt;
if (cnt > k) continue;
++am;
cur = "";
can[a] = 1;
can[b] = 1;
can[c] = 1;
can[d] = 1;
int ndist = go(er, ec);
if (ndist <= dist && ndist != 987654321) {
++am;
rec(sr, sc);
if (ndist < dist || ndist == dist && cur < res) {
dist = ndist;
res = cur;
}
}
can[a] = 0;
can[b] = 0;
can[c] = 0;
can[d] = 0;
}
}
}
}
if (dist == 987654321)
cout << "-1" << endl;
else
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, g, h, t;
string p;
bool operator<(const node& obj) const {
if (g + h != obj.g + obj.h) return g + h > obj.g + obj.h;
return p > obj.p;
}
};
const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, -1, 0, 1};
priority_queue<node> q;
set<pair<pair<int, int>, int> > v;
char a[51][55];
int main(void) {
int n, m, s, sx, sy, tx, ty;
scanf("%d %d %d", &n, &m, &s);
for (int i = 1; i <= n; ++i) {
scanf("%s", a[i] + 1);
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 'S') {
sx = i;
sy = j;
} else if (a[i][j] == 'T') {
tx = i;
ty = j;
}
}
}
node b;
b.x = sx;
b.y = sy;
b.g = 0;
b.h = abs(sx - tx) + abs(sy - ty);
b.t = 0;
b.p = "";
q.push(b);
while (!q.empty()) {
b = q.top();
if (b.h == 0) break;
q.pop();
pair<pair<int, int>, int> temp = make_pair(make_pair(b.x, b.y), b.t);
if (v.count(temp) > 0) continue;
v.insert(temp);
for (int k = 0; k < 4; ++k) {
int i = b.x + dx[k], j = b.y + dy[k];
if ((i < 1) || (i > n) || (j < 1) || (j > m) || (a[i][j] == 'S'))
continue;
node e = b;
e.x += dx[k];
e.y += dy[k];
++e.g;
e.h = abs(i - tx) + abs(j - ty);
if (a[i][j] == 'T') {
q.push(e);
continue;
}
e.t |= (1 << (a[i][j] - 'a'));
int temp = e.t, c = 0;
while (temp > 0) {
c += temp % 2;
temp /= 2;
}
if (c > s) continue;
e.p += a[i][j];
q.push(e);
}
}
if (!q.empty())
cout << q.top().p << endl;
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char board[3000][3000];
int si, sj, fi, fj;
bool found;
string ans;
bool outside(int x, int y) { return (x < 1 || x > n || y < 1 || y > m); }
int bits(int x) {
if (x == 0) return 0;
return bits(x / 2) + x % 2;
}
struct node {
int x, y, mask;
string way;
bool operator<(const node &other) const {
if (way.length() != other.way.length())
return way.length() > other.way.length();
return way > other.way;
}
};
int sx, sy;
set<int> done[55][55];
priority_queue<node> qu;
vector<int> dx, dy;
int smask[55][55];
int main() {
ios_base::sync_with_stdio(0);
dx.push_back(0);
dx.push_back(0);
dx.push_back(1);
dx.push_back(-1);
dy.push_back(-1);
dy.push_back(1);
dy.push_back(0);
dy.push_back(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
string st;
cin >> st;
for (int j = 1; j <= m; j++) {
board[i][j] = st[j - 1];
if (board[i][j] == 'S') {
si = i;
sj = j;
}
if (board[i][j] == 'T') {
fi = i;
fj = j;
}
}
}
node temp;
temp.x = si;
temp.y = sj;
temp.mask = 0;
temp.way = "";
qu.push(temp);
found = 0;
while (qu.size()) {
node cur = qu.top();
qu.pop();
int qx = cur.x;
int qy = cur.y;
if (found) break;
for (int dir = 0; dir < 4; dir++) {
int nx = qx + dx[dir];
int ny = qy + dy[dir];
if (outside(nx, ny)) continue;
if (board[nx][ny] == 'S') continue;
if (board[nx][ny] == 'T' && found == 0) {
found = 1;
ans = cur.way;
break;
}
int nmask = (cur.mask | (1 << (board[nx][ny] - 'a')));
if (bits(nmask) > k) continue;
if (done[nx][ny].find(nmask) != done[nx][ny].end()) continue;
if ((smask[nx][ny] & nmask) == smask[nx][ny] && smask[nx][ny] > 0)
continue;
smask[nx][ny] = nmask;
done[nx][ny].insert(nmask);
temp.x = nx;
temp.y = ny;
temp.mask = nmask;
temp.way = cur.way + board[nx][ny];
qu.push(temp);
}
}
if (found == 0)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char _;
const int maxN = 50 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
const int base = 701;
const int SQ = 330;
const int maxL = 302;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
char a[maxN][maxN];
int sx, sy, tx, ty;
int mark[26], cnt;
string res;
int n, m, k;
int dis[maxN][maxN];
pair<int, int> q[2500];
bool is_ok(int x, int y) {
if (x < 0 || y < 0 || n <= x || m <= y) return false;
return true;
}
pair<int, int> par[maxN][maxN];
int proi[maxN][maxN];
bool cmp(const pair<int, int> &p, const pair<int, int> &q) {
if (a[p.first][p.second] != a[q.first][q.second])
return (a[p.first][p.second] < a[q.first][q.second]);
pair<int, int> pp = par[p.first][p.second], qq = par[q.first][q.second];
return (proi[pp.first][pp.second] < proi[qq.first][qq.second]);
}
string ss;
void solve(int x, int y) {
if (x == tx && y == ty) return;
if (x != sx || y != sy) ss += a[x][y];
solve(par[x][y].first, par[x][y].second);
}
void check() {
memset(dis, 0, sizeof dis);
memset(proi, 0, sizeof proi);
memset(par, -1, sizeof par);
dis[tx][ty] = 1;
int st = 0, en = 0;
q[en++] = {tx, ty};
while (st < en) {
if (st && dis[q[st].first][q[st].second] >
dis[q[st - 1].first][q[st - 1].second]) {
sort(q + st, q + en, cmp);
int cnt = 0;
for (int i = st + 1; i < en; i++) {
if (cmp(q[i - 1], q[i])) cnt++;
proi[q[i].first][q[i].second] = cnt;
}
}
int x = q[st].first, y = q[st].second;
st++;
if (make_pair(x, y) == make_pair(sx, sy)) break;
for (int i = 0; i < 4; i++) {
int v = x + dx[i], u = y + dy[i];
if (is_ok(v, u) && dis[v][u] == 0 &&
(a[v][u] == 'S' || mark[a[v][u] - 'a'] == 1)) {
dis[v][u] = dis[x][y] + 1;
q[en++] = {v, u};
par[v][u] = {x, y};
}
}
}
if (dis[sx][sy] == 0) return;
if (dis[sx][sy] - 2 > (int)res.size()) return;
ss = "";
solve(sx, sy);
if (dis[sx][sy] - 2 < (int)res.size())
res = ss;
else
res = min(res, ss);
}
void bt(int t) {
if (t == 26) return;
if (cnt < k) {
mark[t] = 1;
cnt++;
check();
bt(t + 1);
mark[t] = 0;
cnt--;
}
bt(t + 1);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == 'S') sx = i, sy = j;
if (a[i][j] == 'T') tx = i, ty = j;
}
res = string(3000, 'z');
bt(0);
if (res.size() == 3000) {
cout << -1 << endl;
return 0;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000 * 1000 * 1000;
char tbl[55][55];
bool ap[55][55];
int dst[55][55];
string p[55][55];
bool got[55];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, -1, 0, 1};
string path;
bool SUKASUKA;
int N, M, K;
pair<int, int> s, t;
bool checkPos(int x, int y) {
return x >= 0 && x < N && y >= 0 && y < M && ap[x][y];
}
void solve() {
if (path.empty()) {
path.resize(N * M + 1, 'z' + 1);
}
vector<char> gc;
for (int i = (0); i < (26); ++i)
if (got[i]) {
gc.push_back(char('a' + i));
}
for (int i = (0); i < (N); ++i)
for (int j = (0); j < (M); ++j) {
ap[i][j] = false;
for (int k = (0); k < ((int)gc.size()); ++k)
if (tbl[i][j] == gc[k]) {
ap[i][j] = true;
}
}
ap[s.first][s.second] = ap[t.first][t.second] = true;
for (int i = (0); i < (N); ++i)
for (int j = (0); j < (M); ++j) {
dst[i][j] = INF;
p[i][j] = "";
}
dst[s.first][s.second] = 0;
queue<pair<int, int> > q;
q.push(s);
while (!q.empty()) {
pair<int, int> now = q.front();
q.pop();
for (int k = (0); k < (4); ++k) {
int x = now.first + dx[k], y = now.second + dy[k];
if (checkPos(x, y))
if (dst[x][y] > dst[now.first][now.second] + 1) {
dst[x][y] = dst[now.first][now.second] + 1;
p[x][y] = p[now.first][now.second] + tbl[x][y];
q.push(make_pair(x, y));
} else if (dst[x][y] == dst[now.first][now.second] + 1) {
p[x][y] = min(p[x][y], p[now.first][now.second] + tbl[x][y]);
}
}
}
if (dst[t.first][t.second] == INF) {
return;
}
SUKASUKA = true;
string npath = p[t.first][t.second];
if ((int)npath.size() < (int)path.size() ||
(int)npath.size() == (int)path.size() && npath < path) {
path = npath;
}
}
void gen(int step = 0, int prev = -1) {
if (step == K) {
solve();
} else {
if (prev + 1 == 26) {
return;
}
for (int i = (prev + 1); i < (26); ++i) {
got[i] = true;
gen(step + 1, i);
got[i] = false;
}
}
}
void read() {
cin >> N >> M >> K;
for (int i = (0); i < (N); ++i)
for (int j = (0); j < (M); ++j) {
cin >> tbl[i][j];
if (tbl[i][j] == 'S') {
s.first = i;
s.second = j;
}
if (tbl[i][j] == 'T') {
t.first = i;
t.second = j;
}
}
}
void out() {
if (SUKASUKA) {
for (int i = (0); i < ((int)path.size() - 1); ++i) {
cout << path[i];
}
} else {
cout << "-1";
}
}
int main() {
read();
gen();
out();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T qmin(const T &a, const T &b) {
return a < b ? a : b;
}
template <typename T>
inline T qmax(const T &a, const T &b) {
return a > b ? a : b;
}
template <typename T>
inline void getmin(T &a, const T &b) {
if (a > b) a = b;
}
template <typename T>
inline void getmax(T &a, const T &b) {
if (a < b) a = b;
}
inline void fileio(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const int inf = 1e9 + 7;
const int N = 51, M = 2953;
const int go[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
char g[N][N];
int tp[N][N];
map<int, int> id;
int mask[M], cnt;
int dis[N][N][M];
bool vis[N][N][M], can[N][N][M];
int ans[N][N][M];
vector<pair<pair<int, int>, int> > to[N][N][M];
int n, m, k, sti, stj, edi, edj;
inline void bfs() {
static queue<pair<pair<int, int>, int> > q;
static int st, ed;
dis[sti][stj][1] = 1;
q.push(make_pair(make_pair(sti, stj), 1));
while (!q.empty()) {
pair<pair<int, int>, int> p = q.front();
q.pop();
int i = p.first.first, j = p.first.second, comb = mask[p.second];
if (dis[i][j][p.second] == dis[edi][edj][1]) break;
comb |= (~tp[i][j] ? 1 << tp[i][j] : 0);
for (register int d = 0; d < (4); ++d) {
int ni = i + go[d][0], nj = j + go[d][1];
if (ni < 1 || ni > n || nj < 1 || nj > m || (ni == sti && nj == stj))
continue;
int ncomb = comb;
if (~tp[ni][nj]) {
ncomb &= ~(1 << tp[ni][nj]);
if (__builtin_popcount(ncomb) >= k) continue;
} else {
ncomb = 0;
}
int cid = id[ncomb];
if (dis[ni][nj][cid]) {
if (dis[ni][nj][cid] == dis[i][j][p.second] + 1)
to[i][j][p.second].push_back(make_pair(make_pair(ni, nj), cid));
continue;
}
dis[ni][nj][cid] = dis[i][j][p.second] + 1;
q.push(make_pair(make_pair(ni, nj), cid));
to[i][j][p.second].push_back(make_pair(make_pair(ni, nj), cid));
}
}
}
inline bool cmp(const pair<pair<int, int>, int> &a,
const pair<pair<int, int>, int> &b) {
pair<int, int> p = a.first, q = b.first;
if (g[p.first][p.second] != g[q.first][q.second])
return g[p.first][p.second] < g[q.first][q.second];
if (p.first == edi && p.second == edj) return false;
return cmp(to[p.first][p.second][a.second][ans[p.first][p.second][a.second]],
to[q.first][q.second][b.second][ans[q.first][q.second][b.second]]);
}
inline void dfs(int i, int j, int k) {
if (vis[i][j][k]) return;
vis[i][j][k] = true;
if (i == edi && j == edj) {
can[i][j][k] = true;
return;
}
int bst = -1;
for (register int d = 0; d < (to[i][j][k].size()); ++d) {
pair<pair<int, int>, int> p = to[i][j][k][d];
int ni = p.first.first, nj = p.first.second, nk = p.second;
dfs(ni, nj, nk);
if (can[ni][nj][nk]) {
if (bst == -1 || cmp(p, to[i][j][k][bst])) bst = d;
}
}
if (~bst) {
ans[i][j][k] = bst;
can[i][j][k] = true;
} else
ans[i][j][k] = -1;
}
inline void getans(pair<pair<int, int>, int> a) {
pair<int, int> p = a.first;
if (p.first == edi && p.second == edj) return;
if (p.first != sti || p.second != stj) putchar(g[p.first][p.second]);
getans(to[p.first][p.second][a.second][ans[p.first][p.second][a.second]]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (register int i = (1); i <= (n); ++i) {
scanf("%s", g[i] + 1);
for (register int j = (1); j <= (m); ++j) {
if (g[i][j] == 'S') {
tp[i][j] = -1;
sti = i, stj = j;
} else if (g[i][j] == 'T') {
tp[i][j] = -1;
edi = i, edj = j;
} else {
tp[i][j] = g[i][j] - 'a';
}
}
}
id[0] = ++cnt;
mask[cnt] = 0;
for (register int i = (1); i <= (k - 1); ++i) {
for (int comb = (1 << i) - 1, x, y; comb < (1 << 26);
x = comb & -comb, y = comb + x, comb = ((comb & ~y) / x >> 1) | y) {
id[comb] = ++cnt;
mask[cnt] = comb;
}
}
bfs();
if (!dis[edi][edj][1]) return puts("-1"), 0;
dfs(sti, stj, 1);
getans(make_pair(make_pair(sti, stj), 1));
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char board[3000][3000];
int si, sj, fi, fj;
bool found;
string ans;
bool outside(int x, int y) { return (x < 1 || x > n || y < 1 || y > m); }
int bits(int x) {
if (x == 0) return 0;
return bits(x / 2) + x % 2;
}
struct node {
int x, y, mask;
string way;
bool operator<(const node &other) const {
if (way.length() != other.way.length())
return way.length() > other.way.length();
return way > other.way;
}
};
int sx, sy;
set<int> done[55][55];
priority_queue<node> qu;
vector<int> dx, dy;
int smask[55][55];
int main() {
ios_base::sync_with_stdio(0);
dx.push_back(0);
dx.push_back(0);
dx.push_back(1);
dx.push_back(-1);
dy.push_back(-1);
dy.push_back(1);
dy.push_back(0);
dy.push_back(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
string st;
cin >> st;
for (int j = 1; j <= m; j++) {
board[i][j] = st[j - 1];
if (board[i][j] == 'S') {
si = i;
sj = j;
}
if (board[i][j] == 'T') {
fi = i;
fj = j;
}
}
}
node temp;
temp.x = si;
temp.y = sj;
temp.mask = 0;
temp.way = "";
qu.push(temp);
found = 0;
while (qu.size()) {
node cur = qu.top();
qu.pop();
int qx = cur.x;
int qy = cur.y;
if (found) break;
for (int dir = 0; dir < 4; dir++) {
int nx = qx + dx[dir];
int ny = qy + dy[dir];
if (outside(nx, ny)) continue;
if (board[nx][ny] == 'S') continue;
if (board[nx][ny] == 'T' && found == 0) {
found = 1;
ans = cur.way;
break;
}
int nmask = (cur.mask | (1 << (board[nx][ny] - 'a')));
if (bits(nmask) > k) continue;
if (done[nx][ny].find(nmask) != done[nx][ny].end()) continue;
if ((smask[nx][ny] & nmask) == smask[nx][ny] && smask[nx][ny] > 0)
continue;
smask[nx][ny] = nmask;
done[nx][ny].insert(nmask);
temp.x = nx;
temp.y = ny;
temp.mask = nmask;
temp.way = cur.way + board[nx][ny];
qu.push(temp);
}
}
if (found == 0)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 61;
const int MAXA = 31;
const int INF = 1000000000;
const int MAXM = 10010;
const int w[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
struct P {
P() {}
P(int xx, int yy) : x(xx), y(yy) {}
bool operator==(const P &p) const { return x == p.x && y == p.y; }
int x, y;
} start, target;
char mp[MAXN][MAXN];
int ch[MAXA];
bool vis[MAXA];
int dist[MAXN][MAXN];
int ctot;
int n, m, k;
int ans;
char path[MAXM], curpath[MAXM];
void init() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) scanf("%s", mp[i]);
ctot = 0;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (mp[i][j] == 'S')
start = P(i, j);
else if (mp[i][j] == 'T')
target = P(i, j);
else {
if (!vis[mp[i][j] - 'a']) {
ch[ctot++] = mp[i][j] - 'a';
vis[mp[i][j] - 'a'] = 1;
}
}
k = min(ctot, k);
}
P que[MAXM];
void bfs() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) dist[i][j] = -1;
que[0] = target;
dist[target.x][target.y] = 0;
P p;
for (int k1 = 0, k2 = 1, k3 = 1, step = 1; k1 < k2; k1 = k3, k3 = k2, ++step)
for (int i = k1; i < k3; ++i)
for (int l = 0; l < 4; ++l) {
p.x = que[i].x + w[l][0];
p.y = que[i].y + w[l][1];
if (!(0 <= (p.x) && (p.x) < n && 0 <= (p.y) && (p.y) < m) ||
dist[p.x][p.y] != -1 ||
(mp[p.x][p.y] != 'S' && !vis[mp[p.x][p.y] - 'a']))
continue;
dist[p.x][p.y] = step;
que[k2++] = p;
}
if (dist[start.x][start.y] == -1 || dist[start.x][start.y] > ans) return;
que[0] = start;
int len = 0;
for (int k1 = 0, k2 = 1, k3 = 1, step = dist[start.x][start.y] - 1; k1 < k2;
k1 = k3, k3 = k2, --step) {
char c = 127;
for (int i = k1; i < k3; ++i)
for (int l = 0; l < 4; ++l) {
p.x = que[i].x + w[l][0];
p.y = que[i].y + w[l][1];
if (!(0 <= (p.x) && (p.x) < n && 0 <= (p.y) && (p.y) < m) ||
dist[p.x][p.y] != step)
continue;
c = min(c, mp[p.x][p.y]);
}
if (c == 'T') break;
curpath[len++] = c;
for (int i = k1; i < k3; ++i)
for (int l = 0; l < 4; ++l) {
p.x = que[i].x + w[l][0];
p.y = que[i].y + w[l][1];
if (!(0 <= (p.x) && (p.x) < n && 0 <= (p.y) && (p.y) < m) ||
dist[p.x][p.y] != step || mp[p.x][p.y] != c)
continue;
dist[p.x][p.y] = -1;
que[k2++] = p;
}
}
curpath[len] = '\0';
if (ans > dist[start.x][start.y] || strcmp(curpath, path) < 0) {
ans = dist[start.x][start.y];
strcpy(path, curpath);
}
}
void cal(int step, int pt) {
if (step == 0) {
bfs();
return;
}
for (int i = pt; i <= ctot - step; ++i) {
vis[ch[i]] = 1;
cal(step - 1, i + 1);
vis[ch[i]] = 0;
}
}
void solve() {
memset(vis, 0, sizeof(vis));
ans = INF;
path[0] = 127;
path[1] = '\0';
cal(k, 0);
if (ans == INF)
puts("-1");
else
printf("%s\n", path);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mr[] = {0, 1, 0, -1};
const int mc[] = {1, 0, -1, 0};
int sr, sc, tr, tc;
int dp[52][52];
char a[52][52];
string gao(int x, int n, const string& s) {
if (n) {
string ret = "-1";
for (int i = x; i < 26; i++) {
string tmp = gao(i + 1, n - 1, s + char(i + 'a'));
if (tmp == "-1") continue;
if (ret == "-1" || tmp.size() < ret.size() ||
tmp.size() == ret.size() && tmp < ret)
ret = tmp;
}
return ret;
}
vector<pair<int, int>> u = {{tr, tc}}, v;
memset(dp, 255, sizeof(dp));
dp[tr][tc] = 4;
while (!u.empty()) {
v.clear();
for (auto c : s)
for (auto r : u) {
int fr = r.first;
int fc = r.second;
if (fr == sr && fc == sc) {
string ret;
while (1) {
int o = dp[fr][fc];
fr += mr[o];
fc += mc[o];
if (fr == tr && fc == tc) break;
ret += a[fr][fc];
}
return ret;
}
for (int o = 0; o < 4; o++) {
int dr = fr + mr[o];
int dc = fc + mc[o];
if (a[dr][dc] != c || ~dp[dr][dc]) continue;
dp[dr][dc] = (o + 2) % 4;
v.push_back({dr, dc});
}
}
v.swap(u);
}
return "-1";
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%s", a[i] + 1);
for (int j = 1; j <= m; j++) {
if (a[i][j] == 'S') a[sr = i][sc = j] = '.';
if (a[i][j] == 'T') a[tr = i][tc = j] = '.';
}
}
puts(gao(0, k, ".").c_str());
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int n, m, k, sx, sy, fx, fy;
string s[60], a[60][60], res;
vector<int> qx, qy;
bool ok[26];
bool valid(int x, int y) {
if (x >= 0 && y >= 0 && x < n && y < m) return 1;
return 0;
}
void bfs() {
for (int i = 0; i < qx.size(); i++) {
int x, y;
for (int j = 0; j < 4; j++) {
x = qx[i] + dx[j];
y = qy[i] + dy[j];
if (valid(x, y) &&
(s[x][y] == 'T' || s[x][y] == 'S' || ok[s[x][y] - 'a'])) {
if (a[x][y].size() == 0) {
qx.push_back(x);
qy.push_back(y);
a[x][y] = a[qx[i]][qy[i]] + s[x][y];
} else if ((a[x][y].size() > a[qx[i]][qy[i]].size() + 1) ||
(a[x][y].size() == a[qx[i]][qy[i]].size() + 1 &&
a[x][y] > a[qx[i]][qy[i]] + s[x][y])) {
a[x][y] = a[qx[i]][qy[i]] + s[x][y];
}
}
}
}
}
void f(int x, int y) {
if (x == 0) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) a[i][j].clear();
qx.clear();
qy.clear();
qx.push_back(sx);
qy.push_back(sy);
bfs();
if (a[fx][fy].size()) {
if (!res.size() || res.size() > a[fx][fy].size() ||
(a[fx][fy].size() == res.size() && res > a[fx][fy])) {
res = a[fx][fy];
}
}
} else {
for (int i = y; i < 26; i++) {
ok[i] = 1;
f(x - 1, i + 1);
ok[i] = 0;
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (s[i][j] == 'S') {
sx = i;
sy = j;
}
if (s[i][j] == 'T') {
fx = i;
fy = j;
}
}
f(k, 0);
if (res.size()) {
for (int i = 0; i < res.size() - 1; i++) cout << res[i];
cout << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
char ssG[N][N];
int R, C, KK;
int stx, sty, enx, eny;
struct nodexx {
string str;
int x, y, val;
bool operator<(const nodexx t) const {
int lenaa = str.size(), lenbb = t.str.size();
if (lenaa - lenbb) return lenaa > lenbb;
return str > t.str;
}
} XA, XB;
priority_queue<nodexx> QQ;
set<pair<pair<int, int>, int> > SET;
int dirc[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int has[55][55];
bool Judge(int x) {
int cnt = 0;
while (x > 0) {
cnt += x % 2;
x /= 2;
}
return cnt <= KK;
}
string BFS() {
memset(has, 0, sizeof has);
SET.clear();
while (QQ.size()) QQ.pop();
XA.str = "", XA.x = stx, XA.y = sty, XA.val = 0, QQ.push(XA);
SET.insert(make_pair(make_pair(stx, sty), 0));
int k, r, c, val;
while (QQ.size()) {
XA = QQ.top(), QQ.pop();
for (k = 0; k < 4; k++) {
r = XA.x + dirc[k][0], c = XA.y + dirc[k][1];
if (r >= 0 && r < R && c >= 0 && c < C && ssG[r][c] != 'S') {
if (ssG[r][c] == 'T') return XA.str;
val = XA.val | (1 << (ssG[r][c] - 'a'));
if (Judge(val) && SET.count(make_pair(make_pair(r, c), val)) == 0) {
if (has[r][c] && (has[r][c] & val) == has[r][c]) continue;
has[r][c] = val;
SET.insert(make_pair(make_pair(r, c), val));
XB.str = XA.str + ssG[r][c];
XB.val = val;
XB.x = r;
XB.y = c;
QQ.push(XB);
}
}
}
}
return "-1";
}
void cyh() { cout << BFS() << endl; }
int main() {
int e, f;
while (cin >> R >> C >> KK) {
for (e = 0; e < R; e++) {
scanf("%s", ssG[e]);
for (f = 0; f < C; f++) {
if (ssG[e][f] == 'S') stx = e, sty = f;
if (ssG[e][f] == 'T') enx = e, eny = f;
}
}
cyh();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct triple {
int val, r, c, par;
triple(int _v, int _r, int _c, int _p) { val = _v, r = _r, c = _c, par = _p; }
bool operator<(const triple &a) const { return val > a.val; }
};
int n, m, k, len;
int rs, cs, re, ce;
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
char mat[60][60];
bool mark[60][60];
int dist[60][60];
int par[60][60];
bool ok[30];
string res;
priority_queue<triple> q[2];
string bfs() {
for (int i = 0; i < 2; i++)
while (!q[i].empty()) q[i].pop();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
mark[i][j] = false;
dist[i][j] = -1;
par[i][j] = -1;
}
}
dist[rs][cs] = 0;
int cur = 0, bef = 1, prev, cnt;
q[cur].push(triple(1, rs, cs, -1));
while (!q[0].empty() || !q[1].empty()) {
if (q[bef].empty()) {
bef = 1 - bef;
cur = 1 - cur;
prev = cnt = 0;
}
triple t = q[bef].top();
q[bef].pop();
int r = t.r;
int c = t.c;
int val = t.val;
if (val > prev) cnt++;
prev = val;
if (par[r][c] != -1) continue;
par[r][c] = t.par;
if (r == re && c == ce) break;
for (int i = 0; i < 4; i++) {
int nr = r + dir[i][0];
int nc = c + dir[i][1];
if ((nr == re && nc == ce) ||
(nr >= 0 && nr < n && nc >= 0 && nc < m && ok[mat[nr][nc] - 'a'])) {
if (dist[nr][nc] == -1 || dist[nr][nc] == dist[r][c] + 1) {
dist[nr][nc] = dist[r][c] + 1;
int nval = cnt * 30 + mat[nr][nc] - 'a';
q[cur].push(triple(nval, nr, nc, i));
}
}
}
}
if (par[re][ce] == -1) return "";
string res;
int x = re, y = ce;
while (x != rs || y != cs) {
res = mat[x][y] + res;
int p = par[x][y];
x -= dir[p][0];
y -= dir[p][1];
}
return res;
}
void bt(int str, int rem) {
if (rem == 0) {
string tmp = bfs();
if (tmp.length() < 1) return;
tmp = tmp.substr(0, (int)tmp.length() - 1);
if (len == -1 || tmp.length() < len || (tmp.length() == len && tmp < res)) {
len = tmp.length();
res = tmp;
}
} else {
for (int i = str; i < 26; i++) {
ok[i] = true;
bt(i + 1, rem - 1);
ok[i] = false;
}
}
}
int main() {
while (cin >> n >> m >> k) {
len = -1;
res = "";
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> mat[i][j];
if (mat[i][j] == 'S') rs = i, cs = j;
if (mat[i][j] == 'T') re = i, ce = j;
}
}
bt(0, k);
if (len == -1)
cout << -1 << endl;
else
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int r, c;
};
struct Node2 {
int r, c, pr, pc;
};
int N, M, K, SR, SC, TR, TC;
char grid[52][52], cost2[50 * 50 + 2];
int cost[52][52], SP, mini;
bool vis[52][52], available[512];
int dr[] = {-1, 1, 0, 0}, dc[] = {0, 0, 1, -1};
Node parent[52][52];
string ans;
bool operator<(const Node2 &a, const Node2 &b) {
if (cost[a.r][a.c] != cost[b.r][b.c]) return cost[a.r][a.c] > cost[b.r][b.c];
if (grid[a.r][a.c] != grid[b.r][b.c]) return grid[a.r][a.c] < grid[b.r][b.c];
if (a.r != b.r) return a.r < b.r;
if (a.c != b.c) return a.c < b.c;
if (a.pr != b.pr) return a.pr < b.pr;
return a.pc < b.pc;
}
void getCoordinates(int &R, int &C, char x, char y) {
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
if (grid[i][j] == x) R = i, C = j, grid[i][j] = y;
}
void bfs() {
SP = 1 << 30;
memset(vis, 0, sizeof vis);
memset(cost, 63, sizeof cost);
queue<Node> q;
q.push(Node{TR, TC});
cost[TR][TC] = 0;
while (!q.empty()) {
Node cur = q.front(), t;
q.pop();
if (cur.r == SR && cur.c == SC) {
SP = cost[SR][SC];
return;
}
if (vis[cur.r][cur.c]) continue;
vis[cur.r][cur.c] = true;
for (int i = 0; i < 4; i++) {
t = Node{cur.r + dr[i], cur.c + dc[i]};
if (t.r >= 0 && t.r < N && t.c >= 0 && t.c < M && !vis[t.r][t.c] &&
available[(int)grid[t.r][t.c]] &&
cost[t.r][t.c] > cost[cur.r][cur.c] + 1) {
cost[t.r][t.c] = cost[cur.r][cur.c] + 1;
q.push(t);
}
}
}
}
void dijkstra() {
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) parent[i][j] = Node{-1, -1};
if (cost[SR][SC] >= 1 << 20) return;
memset(vis, 0, sizeof vis);
memset(cost2, 'z' + 5, sizeof cost2);
set<Node2> s;
s.insert(Node2{SR, SC, -1, -1});
while (!s.empty()) {
Node2 cur = *s.begin();
s.erase(s.begin());
if (vis[cur.r][cur.c] ||
cost2[SP - cost[cur.r][cur.c]] < grid[cur.r][cur.c])
continue;
vis[cur.r][cur.c] = true;
cost2[SP - cost[cur.r][cur.c]] = grid[cur.r][cur.c];
parent[cur.r][cur.c] = Node{cur.pr, cur.pc};
if (cur.r == TR && cur.c == TC) return;
for (int i = 0; i < 4; i++) {
Node2 t = Node2{cur.r + dr[i], cur.c + dc[i], cur.r, cur.c};
if (t.r >= 0 && t.r < N && t.c >= 0 && t.c < M &&
cost[t.r][t.c] + 1 == cost[cur.r][cur.c])
s.insert(t);
}
}
}
string getPath() {
Node cur{TR, TC};
string ret = "";
while (cur.r != -1) {
ret += grid[cur.r][cur.c];
cur = parent[cur.r][cur.c];
}
ret = ret.substr(1, (int)ret.size() - 2);
reverse(ret.begin(), ret.end());
return ret;
}
void choose(int k, char from) {
if (k == K) {
bfs();
dijkstra();
string best = getPath();
if (SP < mini || (SP == mini && best < ans)) mini = SP, ans = best;
return;
}
for (char i = from; i <= 'z'; i++) {
available[(int)i] = true;
choose(k + 1, i + 1);
available[(int)i] = false;
}
}
int main() {
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) parent[i][j] = Node{-1, -1};
scanf("%d %d %d", &N, &M, &K);
for (int i = 0; i < N; i++) scanf("%s", grid[i]);
getCoordinates(SR, SC, 'S', 'a' - 1);
getCoordinates(TR, TC, 'T', 'z' + 1);
available['a' - 1] = available['z' + 1] = true;
mini = 1 << 30;
choose(0, 'a');
if (mini == 1 << 30)
printf("-1\n");
else
printf("%s\n", ans.c_str());
}
|
#include <bits/stdc++.h>
using namespace std;
const int dy[] = {-1, 0, 1, 0}, dx[] = {0, -1, 0, 1};
inline int D(int x1, int y1, int x2, int y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
int h, w, k;
string in[50];
void run() {
cin >> h >> w >> k;
int sy, sx, gy, gx;
for (int i = 0; i < h; i++) {
cin >> in[i];
for (int j = 0; j < w; j++) {
if (in[i][j] == 'S')
sy = i, sx = j;
else if (in[i][j] == 'T')
gy = i, gx = j;
}
}
set<pair<int, int> > s;
priority_queue<pair<int, pair<pair<string, int>, int> >,
vector<pair<int, pair<pair<string, int>, int> > >,
greater<pair<int, pair<pair<string, int>, int> > > >
q;
q.push(
make_pair(D(sy, sx, gy, gx), make_pair(make_pair("", 0), sy * w + sx)));
while (!q.empty()) {
int y = q.top().second.second / w, x = q.top().second.second % w;
string str = q.top().second.first.first;
int mask = q.top().second.first.second;
q.pop();
if (s.count(make_pair(mask, y * w + x))) continue;
s.insert(make_pair(mask, y * w + x));
for (int d = 0; d < 4; d++) {
int ny = y + dy[d], nx = x + dx[d];
if (ny < 0 || nx < 0 || ny >= h || nx >= w || ny == sy && nx == sx)
continue;
if (ny == gy && nx == gx) {
cout << str << endl;
return;
}
string next = str + in[ny][nx];
int nmask = mask | 1 << in[ny][nx] - 'a';
if (__builtin_popcount(nmask) <= k)
q.push(make_pair(D(ny, nx, gy, gx) + next.size(),
make_pair(make_pair(next, nmask), ny * w + nx)));
}
}
cout << -1 << endl;
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const long long LINF = 1000000000000000000LL;
void prepare() {}
int n, m, k;
char x[55][55];
pair<int, int> start, finish;
int rev[255];
char rev2[10];
struct mystring {
vector<int> a;
int sz;
mystring() { sz = 10; }
void push_back(char x) {
if (x == 'T') return;
if (sz == 10) {
a.push_back(rev[x] << 27);
sz = 1;
} else {
sz++;
a[a.size() - 1] |= (rev[x] << (3 * (10 - sz)));
}
}
string get(int q, int sz) {
string ret = "";
ret.resize(sz);
for (int i = 0; i < sz; i++) {
ret[i] = rev2[(q >> (3 * (9 - i))) & 7];
}
return ret;
}
string c_str() {
if (a.size() == 0) return "";
string ret = "";
for (int i = 0; i < a.size() - 1; i++) ret += get(a[i], 10);
return ret + get(a[a.size() - 1], sz);
}
};
bool operator<(const mystring &a, const mystring &b) {
for (int i = 0; i < a.a.size(); i++)
if (a.a[i] != b.a[i]) return a.a[i] < b.a[i];
return false;
}
bool operator>(const mystring &a, const mystring &b) {
for (int i = 0; i < a.a.size(); i++)
if (a.a[i] != b.a[i]) return a.a[i] > b.a[i];
return false;
}
bool ok[256];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
queue<pair<int, int> > dq;
int dp[55][55];
pair<int, int> last[55][55];
string rew[55][55];
string getans() {
int sz = dp[finish.first][finish.second];
if (sz == INF) return "";
pair<int, int> cur = finish;
string ret = "";
for (int i = 0; i < sz - 1; i++) {
cur = last[cur.first][cur.second];
ret += x[cur.first][cur.second];
}
reverse(ret.begin(), ret.end());
return ret;
}
inline string rewind(pair<int, int> z) {
string ret = "";
int gg = dp[z.first][z.second], i = 0;
ret.resize(gg + 1);
while (z.first != -1) {
ret[gg - i] = x[z.first][z.second];
z = last[z.first][z.second];
i++;
}
return ret;
}
bool dij() {
for (int i = 0; i < 55; i++)
for (int j = 0; j < 55; j++) {
dp[i][j] = INF;
rew[i][j] = "";
}
dp[start.first][start.second] = 0;
dq.push(start);
while (!dq.empty()) {
pair<int, int> cur = dq.front();
dq.pop();
string r = rew[cur.first][cur.second];
if (cur != start) r.push_back(x[cur.first][cur.second]);
for (int k = 0; k < 4; k++) {
int nr = cur.first + dy[k];
int nc = cur.second + dx[k];
if (nr >= 0 && nr < n && nc >= 0 && nc < m)
if (ok[x[nr][nc]]) {
int nval = dp[cur.first][cur.second] + 1;
if (dp[nr][nc] > nval) {
dp[nr][nc] = nval;
rew[nr][nc] = r;
dq.push(make_pair(nr, nc));
} else if (dp[nr][nc] == nval) {
if (rew[nr][nc] > r) rew[nr][nc] = r;
}
}
}
}
return dp[finish.first][finish.second] != INF;
}
pair<int, string> ans;
bool use[256];
int qq;
void go(int it, char last) {
if (it == 0) {
if (dij()) {
pair<int, string> tmp = make_pair(dp[finish.first][finish.second],
rew[finish.first][finish.second]);
if (ans > tmp) ans = tmp;
}
return;
}
for (char x = last; x <= 'z'; x++)
if (use[x]) {
ok[x] = true;
rev[x] = 5 - it;
rev2[5 - it] = x;
go(it - 1, x + 1);
ok[x] = false;
}
}
bool solve() {
memset(use, 0, sizeof(use));
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%s", x[i]);
for (int j = 0; j < m; j++) {
use[x[i][j]] = true;
if (x[i][j] == 'S')
start = make_pair(i, j);
else if (x[i][j] == 'T')
finish = make_pair(i, j);
}
}
memset(ok, 0, sizeof(ok));
ok['S'] = true;
ok['T'] = true;
int sk = 0;
for (char a = 'a'; a <= 'z'; a++)
if (use[a]) sk++;
k = min(k, sk);
ans = make_pair(INF, "Z");
go(k, 'a');
if (ans.first == INF)
printf("-1\n");
else {
for (int i = 0; i < ans.second.size(); i++) printf("%c", ans.second[i]);
printf("\n");
}
return false;
}
int main() {
prepare();
while (solve())
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
char h;
string res;
bool poss;
};
point a[50][50];
int n, m, k;
string res;
vector<int> qx, qy;
int step[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
void bfs() {
for (int i = 0; i < qx.size(); i++) {
int x, y;
for (int j = 0; j < 4; j++) {
x = qx[i] + step[j][0];
y = qy[i] + step[j][1];
if (x > -1 && y > -1 && x < n && y < m && a[x][y].poss) {
if (a[x][y].res.size() == 0) {
qx.push_back(x);
qy.push_back(y);
a[x][y].res = a[qx[i]][qy[i]].res + a[x][y].h;
} else {
if (a[x][y].res.size() == a[qx[i]][qy[i]].res.size() + 1 &&
a[x][y].res > a[qx[i]][qy[i]].res + a[x][y].h) {
a[x][y].res = a[qx[i]][qy[i]].res + a[x][y].h;
}
}
}
}
}
}
vector<char> temp, meeted;
char now[6];
int startx, starty, fx, fy;
void pere(int deep, int start) {
for (int i = start; i < meeted.size(); i++) {
now[deep + 2] = meeted[i];
if (deep == k - 1) {
qx.clear();
qy.clear();
qx.push_back(startx);
qy.push_back(starty);
for (int ii = 0; ii < n; ii++)
for (int jj = 0; jj < m; jj++) {
a[ii][jj].res.clear();
a[ii][jj].poss = false;
for (int j = 0; j < k + 2; j++)
if (a[ii][jj].h == now[j]) a[ii][jj].poss = true;
}
a[startx][starty].res = "S";
bfs();
if (a[fx][fy].res.size()) {
if (!res.size() || res.size() > a[fx][fy].res.size() ||
(a[fx][fy].res.size() == res.size() && res > a[fx][fy].res))
res = a[fx][fy].res;
}
} else {
pere(deep + 1, i + 1);
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j].h;
if (a[i][j].h == 'S') {
startx = i;
starty = j;
}
if (a[i][j].h == 'T') {
fx = i;
fy = j;
}
if (a[i][j].h >= 'a') temp.push_back(a[i][j].h);
}
}
now[0] = 'S';
now[1] = 'T';
sort(temp.begin(), temp.end());
for (int i = 0; i < temp.size(); i++) {
if (!i || temp[i] != temp[i - 1]) meeted.push_back(temp[i]);
}
k = min(k, int(meeted.size()));
if (meeted.size() == 0) return 0;
pere(0, 0);
if (res.size() == 0)
cout << -1;
else {
for (int i = 1; i < res.size() - 1; i++) cout << res[i];
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 2e9;
const long long INF64 = 9e18;
const long double EPS = 1e-12;
const long double PI = 3.1415926535897932384626433832795028841;
const long long MD = 925262732;
const long long T = 634521;
const int N = 200010;
const int M = 201;
int n, m, k, c[5], mini = INF, d[51][51];
bool mark[51][51];
string ans, a[M];
pair<int, int> s, f;
queue<pair<int, int> > q;
vector<pair<int, int> > qq[3];
bool get(int first, int second) {
if (!(first >= 0 && second >= 0 && first < n && second < m)) return 0;
bool f = 0;
for (int i = 0; i < int(k); i++)
if (a[first][second] == c[i]) f = 1;
if (a[first][second] == 'S') f = 1;
return f;
}
void bfs() {
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(m); j++) {
d[i][j] = INF;
mark[i][j] = 0;
}
d[f.first][f.second] = 0;
q.push(f);
while (!q.empty()) {
pair<int, int> v = q.front();
q.pop();
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++)
if (abs(i) + abs(j) == 1)
if (get(v.first + i, v.second + j) &&
d[v.first + i][v.second + j] > d[v.first][v.second] + 1) {
q.push(make_pair(v.first + i, v.second + j));
d[v.first + i][v.second + j] = d[v.first][v.second] + 1;
}
}
int sum = d[s.first][s.second];
int ss = sum;
if (sum == INF) return;
if (sum == 1) exit(0);
string s1 = "";
int first = s.first, second = s.second;
qq[0].clear();
qq[1].clear();
qq[sum % 2].push_back(s);
while (sum > 1) {
int c = 'z';
int t = sum % 2, tt = (sum - 1) % 2;
qq[tt].clear();
for (int u = 0; u < int(int((qq[t]).size())); u++)
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++)
if (abs(i) + abs(j) == 1) {
int xx = qq[t][u].first + i, yy = qq[t][u].second + j;
if (get(xx, yy) && d[xx][yy] == sum - 1 && a[xx][yy] <= c)
c = a[xx][yy];
}
for (int u = 0; u < int(int((qq[t]).size())); u++)
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++)
if (abs(i) + abs(j) == 1) {
int xx = qq[t][u].first + i, yy = qq[t][u].second + j;
if (get(xx, yy) && d[xx][yy] == sum - 1 && a[xx][yy] == c &&
!mark[xx][yy]) {
qq[tt].push_back(make_pair(xx, yy));
mark[xx][yy] = 1;
}
}
if (c != 'S') s1 = s1 + (char)c;
sum--;
}
if (ss < mini) {
mini = ss;
ans = s1;
} else if (ss == mini)
ans = min(ans, s1);
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < int(n); i++) {
cin >> a[i];
for (int j = 0; j < int(m); j++)
if (a[i][j] == 'S')
s = make_pair(i, j);
else if (a[i][j] == 'T')
f = make_pair(i, j);
}
for (c[0] = 'a'; c[0] <= 'z'; c[0]++)
for (c[1] = c[0]; c[1] <= 'z'; c[1]++)
for (c[2] = c[1]; c[2] <= 'z'; c[2]++)
for (c[3] = c[2]; c[3] <= 'z'; c[3]++) bfs();
if (mini == INF)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
struct state {
int x, y, h;
string s;
state(int a, int b, int c, string d) : x(a), y(b), h(c), s(d) {}
bool operator<(const state &b) const {
return b.s.size() != s.size() ? s.size() > b.s.size() : s > b.s;
}
};
char a[55][55];
int n, m, lim, last[55][55];
set<int> s[55][55];
int main() {
cin >> n >> m >> lim;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == 'S') {
priority_queue<state> q;
q.push({i, j, 0, ""});
while (!q.empty()) {
auto cur = q.top();
q.pop();
for (int d = 0; d < 4; d++) {
int x = cur.x + dx[d], y = cur.y + dy[d];
if (x < 0 || y < 0 || x >= n || y >= m) continue;
if (a[x][y] == 'T') {
cout << cur.s << '\n';
exit(0);
}
if (a[x][y] == 'S') continue;
int h = cur.h | (1 << (a[x][y] - 'a'));
if (__builtin_popcount(h) > lim || s[x][y].count(h)) continue;
if (last[x][y] && (last[x][y] & h) == last[x][y]) continue;
last[x][y] = h;
s[x][y].insert(h);
q.push({x, y, h, cur.s + a[x][y]});
}
}
puts("-1");
exit(0);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int sx, sy, tx, ty;
char a[60][60];
bool ok[26];
int dis[60][60];
int d[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
int val[60][60];
pair<int, int> lst[60][60];
vector<pair<int, int> > tot[110];
vector<int> fst[26];
vector<int> snd[2510];
string ans;
bool good;
void solve() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) dis[i][j] = -1;
dis[sx][sy] = 0;
queue<pair<int, int> > q;
q.push(make_pair(sx, sy));
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int xx = x + d[i][0], yy = y + d[i][1];
if (xx < 1 || xx > n || yy < 1 || yy > m) continue;
if (dis[xx][yy] != -1 || (a[xx][yy] != 'T' && !ok[a[xx][yy] - 'a']))
continue;
dis[xx][yy] = dis[x][y] + 1;
q.push(make_pair(xx, yy));
}
}
if (dis[tx][ty] == -1) return;
for (int i = 1; i <= dis[tx][ty]; i++) tot[i].clear();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dis[i][j] <= 0 || dis[i][j] > dis[tx][ty]) continue;
tot[dis[i][j]].push_back(make_pair(i, j));
}
}
val[sx][sy] = 1;
int sz = 1;
for (int i = 1; i <= dis[tx][ty]; i++) {
for (int j = 0; j < 26; j++) fst[j].clear();
for (int j = 1; j <= sz; j++) snd[j].clear();
for (int j = 0; j < (int)tot[i].size(); j++) {
int x = tot[i][j].first, y = tot[i][j].second;
if (a[x][y] != 'T') fst[a[x][y] - 'a'].push_back(j);
val[x][y] = 1e9;
for (int t = 0; t < 4; t++) {
int xx = x + d[t][0], yy = y + d[t][1];
if (xx < 1 || xx > n || yy < 1 || yy > m) continue;
if (dis[xx][yy] != dis[x][y] - 1) continue;
if (val[xx][yy] < val[x][y])
val[x][y] = val[xx][yy], lst[x][y] = make_pair(xx, yy);
}
}
for (int j = 0; j < 26; j++) {
for (int t = 0; t < (int)fst[j].size(); t++) {
int x = tot[i][fst[j][t]].first, y = tot[i][fst[j][t]].second;
snd[val[x][y]].push_back(fst[j][t]);
}
}
int tsz = 0;
int lx = 0, ly = 0, lv = 0;
for (int j = 1; j <= sz; j++) {
for (int t = 0; t < (int)snd[j].size(); t++) {
int x = tot[i][snd[j][t]].first, y = tot[i][snd[j][t]].second;
if (lx && ly && lv == val[x][y] && a[lx][ly] == a[x][y])
lv = val[x][y], val[x][y] = tsz;
else
lv = val[x][y], val[x][y] = ++tsz;
lx = x;
ly = y;
}
}
sz = tsz;
}
string res = "";
int x = lst[tx][ty].first, y = lst[tx][ty].second;
while (x != sx || y != sy) {
res = a[x][y] + res;
int ttx = lst[x][y].first, tty = lst[x][y].second;
x = ttx;
y = tty;
}
if (!good || (int)res.size() < (int)ans.size() ||
((int)res.size() == (int)ans.size() && res < ans))
ans = res;
good = true;
}
void dfs(int x, int lst) {
if (x > k) {
solve();
return;
}
for (int i = lst; i < 26; i++) {
ok[i] = true;
dfs(x + 1, i + 1);
ok[i] = false;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%s", a[i] + 1);
for (int j = 1; j <= m; j++) {
if (a[i][j] == 'S') sx = i, sy = j;
if (a[i][j] == 'T') tx = i, ty = j;
}
}
dfs(1, 0);
if (!good)
printf("-1");
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : (-x);
}
template <class T>
T sqr(T x) {
return x * x;
}
const int maxn = 57;
char ty[maxn][maxn];
bool allow[300];
int d[maxn][maxn];
int f[maxn][maxn];
int n, m, k;
int sx, sy, fx, fy;
int Q[maxn * maxn * 2];
int qs, qt;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
void bfs() {
d[sx][sy] = 0;
qs = 0, qt = 0;
Q[qs++] = sx * maxn + sy;
while (qs > qt) {
int x = Q[qt] / maxn;
int y = Q[qt] % maxn;
if (x == fx && y == fy) break;
++qt;
for (int dir = 0; dir < 4; ++dir) {
int X = x + dx[dir], Y = y + dy[dir];
if (X < 0 || Y < 0 || X >= n || Y >= m) continue;
if (d[X][Y] != -1) continue;
if (!allow[ty[X][Y]]) continue;
d[X][Y] = d[x][y] + 1;
f[X][Y] = x * maxn + y;
Q[qs++] = X * maxn + Y;
}
}
}
string cur;
string rf[maxn][maxn];
bool uf[maxn][maxn];
void rest() {
memset(uf, 0, sizeof(uf));
rf[sx][sy] = "S";
qs = 0, qt = 0;
uf[sx][sy] = true;
Q[qs++] = sx * maxn + sy;
while (qs > qt) {
int x = Q[qt] / maxn;
int y = Q[qt] % maxn;
if (x == fx && y == fy) break;
++qt;
string& s = rf[x][y];
for (int dir = 0; dir < 4; ++dir) {
int X = x + dx[dir], Y = y + dy[dir];
if (X < 0 || Y < 0 || X >= n || Y >= m) continue;
if (d[X][Y] != d[x][y] + 1) continue;
if (!uf[X][Y]) {
uf[X][Y] = true;
rf[X][Y] = rf[x][y] + ty[X][Y];
Q[qs++] = X * maxn + Y;
} else {
rf[X][Y] = min(rf[X][Y], rf[x][y] + ty[X][Y]);
}
}
}
cur = rf[fx][fy];
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int j = 0; j < m; ++j) {
ty[i][j] = s[j];
if (islower(s[j])) {
continue;
}
if (s[j] == 'S')
sx = i, sy = j;
else
fx = i, fy = j;
}
}
int res = 100500100;
string rs;
bool rsf = false;
set<long long> S;
for (int i = 'a'; i <= 'z'; ++i)
for (int j = 'a'; j <= i; ++j)
for (int p = 'a'; p <= j; ++p)
for (int q = 'a'; q <= p; ++q) {
long long h = 123;
if (k >= 1) h = h * 2184057 + i;
if (k >= 2) h = h * 2184057 + j;
if (k >= 3) h = h * 2184057 + p;
if (k >= 4) h = h * 2184057 + q;
if (S.count(h)) continue;
S.insert(h);
memset(allow, 0, sizeof(allow));
if (k >= 1) allow[i] = true;
if (k >= 2) allow[j] = true;
if (k >= 3) allow[p] = true;
if (k >= 4) allow[q] = true;
allow['S'] = allow['T'] = true;
memset(d, -1, sizeof(d));
bfs();
if (d[fx][fy] == -1) continue;
if (d[fx][fy] > res) continue;
if (res > d[fx][fy]) res = d[fx][fy];
}
S.clear();
int bad = 1000000;
for (int i = 'a'; i <= 'z'; ++i)
for (int j = 'a'; j <= i; ++j)
for (int p = 'a'; p <= j; ++p)
for (int q = 'a'; q <= p; ++q) {
if (i >= bad && j >= bad && p >= bad && q >= bad) continue;
long long h = 123;
if (k >= 1) h = h * 2184057 + i;
if (k >= 2) h = h * 2184057 + j;
if (k >= 3) h = h * 2184057 + p;
if (k >= 4) h = h * 2184057 + q;
if (S.count(h)) continue;
S.insert(h);
memset(allow, 0, sizeof(allow));
if (k >= 1) allow[i] = true;
if (k >= 2) allow[j] = true;
if (k >= 3) allow[p] = true;
if (k >= 4) allow[q] = true;
allow['S'] = allow['T'] = true;
memset(d, -1, sizeof(d));
bfs();
if (d[fx][fy] == -1) continue;
if (d[fx][fy] > res) continue;
rest();
if (!rsf || cur < rs) {
rsf = true, rs = cur;
bad = -1;
for (int t = 0; t < ((int)(cur).size()); ++t)
bad = max(bad, (int)cur[t]);
}
}
if (res == 100500100) res = -1;
if (res == -1)
cout << res << "\n";
else
cout << rs.substr(1, ((int)(rs).size()) - 2) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, S, T, dir[4] = {1, -1};
char *grid;
inline int dis(int i, int j) { return abs(i / m - j / m) + abs(i % m - j % m); }
string dijkstra() {
priority_queue<tuple<int, string, int, int>,
vector<tuple<int, string, int, int> >,
greater<tuple<int, string, int, int> > >
q;
set<pair<int, int> > vis;
q.push(make_tuple(dis(S, T), "", 0, S));
while (!q.empty()) {
auto c = q.top();
string path = get<1>(c);
int i = get<3>(c);
int mask = get<2>(c);
q.pop();
if (vis.insert(make_pair(i, mask)).second)
for (int j = 0; j < 4; j++) {
int t = mask | (1 << (grid[i + dir[j]] - 'a'));
if (grid[i + dir[j]] == 'S')
continue;
else if (grid[i + dir[j]] == 'T')
return path;
else if (__builtin_popcount(t) <= k &&
!vis.count(make_pair(i + dir[j], t)))
q.push(make_tuple(dis(i + dir[j], T) + path.size() + 1,
path + grid[i + dir[j]], t, i + dir[j]));
}
}
return "-1";
}
int main() {
cin >> n >> m >> k;
n += 2, dir[3] = -(dir[2] = m += 2);
grid = (char *)malloc(n * m);
memset(grid, 'S', n * m);
for (int i = 1; i < n - 1; i++)
for (int j = 1; j < m - 1; j++) {
cin >> grid[i * m + j];
if (grid[i * m + j] == 'S') S = i * m + j;
if (grid[i * m + j] == 'T') T = i * m + j;
}
cout << dijkstra() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
int size(T& a) {
return (int)a.size();
}
const int MAXN = 51;
const int INF = 1000000000;
char s[MAXN][MAXN];
bool can[26];
int n, m, k;
int sx, sy, fx, fy;
int d[MAXN][MAXN];
bool used[MAXN][MAXN];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
bool valid(int y, int x) {
return x >= 0 && y >= 0 && x < m && y < n &&
(s[y][x] == 'T' || s[y][x] == 'S' || can[s[y][x] - 'a']) &&
d[y][x] == INF;
}
struct Qu {
int qx[MAXN * MAXN];
int qy[MAXN * MAXN];
int head, tail;
Qu() {
head = 0;
tail = 0;
}
pair<int, int> pop() {
int x = qx[tail];
int y = qy[tail];
++tail;
return make_pair(y, x);
}
void clear() {
head = 0;
tail = 0;
}
void operator=(const Qu& que) {
head = que.head;
for (int i = (0); i < (head); ++i) qx[i] = que.qx[i], qy[i] = que.qy[i];
}
void push(int x, int y) {
qx[head] = x;
qy[head] = y;
head++;
}
int size() { return head - tail; }
};
Qu cur, nxt, Q;
int ans = INF;
string res = "";
void brute(int pos, int take) {
if (pos == 26) {
Q.clear();
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) d[i][j] = INF;
if (can['y' - 'a']) {
int br = 1;
}
d[fy][fx] = 0;
Q.push(fx, fy);
while (size(Q) > 0) {
pair<int, int> p = Q.pop();
for (int u = (0); u < (4); ++u)
if (valid(p.first + dy[u], p.second + dx[u])) {
Q.push(p.second + dx[u], p.first + dy[u]);
d[p.first + dy[u]][p.second + dx[u]] = d[p.first][p.second] + 1;
}
}
if (d[sy][sx] == INF) return;
string path = "";
cur.push(sx, sy);
memset((used), (false), sizeof(used));
while (size(cur) > 0) {
int minSymbol = INF;
for (int i = (0); i < (size(cur)); ++i) {
int x = cur.qx[i];
int y = cur.qy[i];
for (int u = (0); u < (4); ++u) {
int nx = x + dx[u];
int ny = y + dy[u];
if (nx >= 0 && ny >= 0 && nx < m && ny < n &&
d[ny][nx] == d[y][x] - 1 &&
(s[ny][nx] == 'S' || s[ny][nx] == 'T' || can[s[ny][nx] - 'a'])) {
minSymbol = min(minSymbol, (int)s[ny][nx]);
}
}
}
nxt.clear();
if (minSymbol != 'T') path += (char)(minSymbol);
for (int i = (0); i < (size(cur)); ++i) {
int x = cur.qx[i];
int y = cur.qy[i];
for (int u = (0); u < (4); ++u) {
int nx = x + dx[u];
int ny = y + dy[u];
if (nx >= 0 && ny >= 0 && nx < m && ny < n &&
d[ny][nx] == d[y][x] - 1 &&
(s[ny][nx] == 'S' || s[ny][nx] == 'T' || can[s[ny][nx] - 'a']) &&
s[ny][nx] == minSymbol && !used[ny][nx]) {
nxt.push(nx, ny);
used[ny][nx] = true;
}
}
}
cur = nxt;
}
if (ans > d[sy][sx] || (ans == d[sy][sx] && res > path)) {
ans = d[sy][sx];
res = path;
}
} else {
if (take > 0) {
can[pos] = true;
brute(pos + 1, take - 1);
}
can[pos] = false;
brute(pos + 1, take);
}
}
void solve() {
scanf("%d%d%d\n", &n, &m, &k);
for (int i = (0); i < (n); ++i) {
gets(s[i]);
for (int j = (0); j < (m); ++j)
if (s[i][j] == 'S')
sx = j, sy = i;
else if (s[i][j] == 'T')
fx = j, fy = i;
}
brute(0, k);
if (ans == INF)
cout << "-1";
else
printf("%s", res.c_str());
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
bool can[555];
bool vis[55][55];
char layout[55][55];
int dist[55][55];
int from[55][55];
int rnk[55][55];
char bst[2510];
vector<pair<int, int> > bpos[2510];
int sz[2510];
int sx, sy, tx, ty;
inline bool legal(int i, int j) { return i && j && (i <= n && j <= m); }
int res = 10000000;
string op;
void upd() {
memset(dist, 0, sizeof(dist));
memset(vis, 0, sizeof(vis));
dist[tx][ty] = 1;
queue<pair<int, int> > q;
q.push(make_pair(tx, ty));
while (!q.empty()) {
int cx = q.front().first, cy = q.front().second;
q.pop();
for (int i = 3; ~i; --i) {
int nx = cx + dx[i], ny = cy + dy[i];
if (legal(nx, ny) && !dist[nx][ny] && can[layout[nx][ny]]) {
dist[nx][ny] = dist[cx][cy] + 1;
q.push(make_pair(nx, ny));
}
}
}
if (!dist[sx][sy] || dist[sx][sy] > res) return;
string ans = "";
bst[1] = ' ';
bpos[1].clear();
bpos[1].push_back(make_pair(sx, sy));
sz[1] = 1;
vis[sx][sy] = 1;
for (int i = 1; i < dist[sx][sy] - 1; ++i) {
bst[i + 1] = 'z';
bpos[i + 1].clear();
for (int j = sz[i] - 1; ~j; --j) {
int nx = bpos[i][j].first, ny = bpos[i][j].second;
for (int k = 3; ~k; --k) {
int tx = nx + dx[k], ty = ny + dy[k];
if (legal(tx, ty) && dist[tx][ty] == dist[nx][ny] - 1) {
if (bst[i + 1] > layout[tx][ty]) bst[i + 1] = layout[tx][ty];
}
}
}
sz[i + 1] = 0;
ans += bst[i + 1];
for (int j = sz[i] - 1; ~j; --j) {
int nx = bpos[i][j].first, ny = bpos[i][j].second;
for (int k = 3; ~k; --k) {
int tx = nx + dx[k], ty = ny + dy[k];
if (legal(tx, ty) && !vis[tx][ty] && dist[tx][ty] == dist[nx][ny] - 1 &&
bst[i + 1] == layout[tx][ty]) {
bpos[i + 1].push_back(make_pair(tx, ty));
vis[tx][ty] = 1;
++sz[i + 1];
}
}
}
}
if (res > dist[sx][sy] || ans < op) {
res = dist[sx][sy];
op = ans;
}
}
int main(void) {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i) {
scanf("%s", layout[i] + 1);
for (int j = 1; j <= m; ++j) {
if (layout[i][j] == 'S') {
sx = i;
sy = j;
}
if (layout[i][j] == 'T') {
tx = i;
ty = j;
}
}
}
can['S'] = 1;
for (int i = 0; i < 26; ++i) {
if (q == 1) {
can[i + 'a'] = 1;
upd();
can[i + 'a'] = 0;
continue;
}
for (int j = i + 1; j < 26; ++j) {
if (q == 2) {
can[i + 'a'] = 1;
can[j + 'a'] = 1;
upd();
can[i + 'a'] = 0;
can[j + 'a'] = 0;
continue;
}
for (int k = j + 1; k < 26; ++k) {
if (q == 3) {
can[i + 'a'] = 1;
can[j + 'a'] = 1;
can[k + 'a'] = 1;
upd();
can[i + 'a'] = 0;
can[j + 'a'] = 0;
can[k + 'a'] = 0;
continue;
}
for (int l = k + 1; l < 26; ++l) {
can[i + 'a'] = 1;
can[j + 'a'] = 1;
can[k + 'a'] = 1;
can[l + 'a'] = 1;
upd();
can[i + 'a'] = 0;
can[j + 'a'] = 0;
can[k + 'a'] = 0;
can[l + 'a'] = 0;
}
}
}
}
if (res > 1000000) {
printf("-1");
return 0;
}
printf("%s", op.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char table[51][51];
int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[] = {0, -1, 0, 1, 1, -1, -1, 1};
int mem[50][50][17903];
struct State {
int r, c;
int vis;
int& ref() { return mem[r][c][vis]; }
};
int stateToMask[18000];
int main(int argc, char* argv[]) {
int N;
cin >> N;
int M;
cin >> M;
int K;
cin >> K;
int cnt = 0;
set<int> m;
for (int a = 0; a <= 'z' - 'a'; a++) {
for (int b = 0; b <= a; b++) {
for (int c = 0; c <= b; c++) {
for (int d = 0; d <= c; d++) {
int mask = (1 << a) | (1 << b) | (1 << c) | (1 << d);
int bcnt = 1;
if (b != a) bcnt++;
if (c != a && c != b) bcnt++;
if (d != c && d != a && d != b) bcnt++;
if (bcnt != K) continue;
if (m.find(mask) != m.end()) continue;
m.insert(mask);
stateToMask[cnt] = mask;
cnt++;
}
}
}
}
for (int i = 0; i < N; i++) scanf("%s", table[i]);
memset(mem, -1, sizeof(mem));
State s;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (table[i][j] == 'T') {
s.c = j;
s.r = i;
}
}
}
queue<State> q;
for (int mask = 0; mask < cnt; mask++) {
s.vis = mask;
s.ref() = 0;
q.push(s);
}
while (!q.empty()) {
State s = q.front();
q.pop();
int len = s.ref();
int mask = stateToMask[s.vis];
for (int k = 0; k < 4; k++) {
State ns;
ns.c = s.c + dx[k];
ns.r = s.r + dy[k];
ns.vis = s.vis;
if (ns.c < 0 || ns.c >= M) continue;
if (ns.r < 0 || ns.r >= N) continue;
if (table[ns.r][ns.c] != 'S' && table[ns.r][ns.c] != 'T') {
if ((mask & (1 << (table[ns.r][ns.c] - 'a'))) == 0) continue;
}
if (ns.ref() == -1) {
ns.ref() = len + 1;
q.push(ns);
}
}
}
int len = 1000000;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (table[i][j] == 'S') {
s.c = j;
s.r = i;
}
}
}
for (int i = 0; i < cnt; i++) {
if (mem[s.r][s.c][i] != -1) {
len = min(len, mem[s.r][s.c][i]);
}
}
if (len == 1000000) {
printf("-1\n");
return 0;
}
vector<State> qq;
string ans;
for (int vis = 0; vis < cnt; vis++) {
s.vis = vis;
if (mem[s.r][s.c][vis] == len) qq.push_back(s);
}
for (int i = 0; i < len - 1; i++) {
char next = 'z' + 1;
for (int j = 0; j < qq.size(); j++) {
State s = qq[j];
int mask = stateToMask[s.vis];
for (int k = 0; k < 4; k++) {
State ns;
ns.c = s.c + dx[k];
ns.r = s.r + dy[k];
ns.vis = s.vis;
if (ns.c < 0 || ns.c >= M) continue;
if (ns.r < 0 || ns.r >= N) continue;
if (table[ns.r][ns.c] != 'S' && table[ns.r][ns.c] != 'T')
if (((mask & (1 << (table[ns.r][ns.c] - 'a')))) == 0) continue;
if (ns.ref() + i == len - 1) {
next = min(next, table[ns.r][ns.c]);
}
}
}
ans += next;
vector<State> nq;
for (int j = 0; j < qq.size(); j++) {
State s = qq[j];
int mask = stateToMask[s.vis];
for (int k = 0; k < 4; k++) {
State ns;
ns.c = s.c + dx[k];
ns.r = s.r + dy[k];
ns.vis = s.vis;
if (ns.c < 0 || ns.c >= M) continue;
if (ns.r < 0 || ns.r >= N) continue;
if (table[ns.r][ns.c] != 'S' && table[ns.r][ns.c] != 'T')
if (((mask & (1 << (table[ns.r][ns.c] - 'a')))) == 0) continue;
if (next == table[ns.r][ns.c] && ns.ref() + i == len - 1) {
nq.push_back(ns);
ns.ref() = -2;
}
}
}
nq.swap(qq);
}
printf("%s\n", ans.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 100 + 10;
char board[M][M];
char graph[M][M];
struct NODE {
int parent_row;
int parent_col;
int dis;
int visited;
string par;
} node[M][M];
int cnt = 0;
int pattern[26 * 26 * 26 * 26][5];
void nchoosek(int num, int *a, int tar, int len, int isize, int spe) {
if (isize == tar) {
int j = 0;
for (int i = 0; i < len; i++) {
if (a[i] == 1) {
pattern[cnt][j] = i;
j++;
}
}
cnt++;
return;
} else {
for (int i = num; i < len; i++) {
if (i != spe) {
a[i] = 1;
nchoosek(i + 1, a, tar, len, isize + 1, spe);
a[i] = 0;
}
}
return;
}
}
string ans;
int LEN = 1E+9;
int dir[8] = {0, 1, 0, -1, -1, 0, 1, 0};
int n, m;
void BFS(int sr, int sc, int er, int ec) {
queue<pair<int, int> > Q;
Q.push(make_pair(sr, sc));
node[sr][sc].visited = 1;
node[sr][sc].dis = 0;
while (!Q.empty()) {
int row = Q.front().first;
int col = Q.front().second;
Q.pop();
for (int i = 0; i < 8; i = i + 2) {
int nrow = row + dir[i];
int ncol = col + dir[i + 1];
if (nrow >= 0 && nrow < n && ncol >= 0 && ncol < m &&
(graph[nrow][ncol] == 'O' || graph[nrow][ncol] == 'T')) {
if (node[nrow][ncol].visited == 1) {
if (node[nrow][ncol].dis == node[row][col].dis + 1) {
int prow = node[nrow][ncol].parent_row;
int pcol = node[nrow][ncol].parent_col;
if (node[row][col].par < node[prow][pcol].par) {
node[nrow][ncol].parent_row = row;
node[nrow][ncol].parent_col = col;
node[nrow][ncol].par = node[row][col].par + board[nrow][ncol];
}
}
} else {
node[nrow][ncol].parent_row = row;
node[nrow][ncol].parent_col = col;
node[nrow][ncol].dis = node[row][col].dis + 1;
node[nrow][ncol].visited = 1;
node[nrow][ncol].par = node[row][col].par + board[nrow][ncol];
if (nrow == er && ncol == ec) {
;
} else {
Q.push(make_pair(nrow, ncol));
}
}
}
}
}
if (node[er][ec].visited == 1) {
int row = er;
int col = ec;
vector<char> tmp;
while (row != sr || col != sc) {
tmp.push_back(board[row][col]);
int irow = node[row][col].parent_row;
int icol = node[row][col].parent_col;
row = irow;
col = icol;
}
tmp.push_back(board[sr][sc]);
if (tmp.size() < LEN) {
ans = "";
for (int i = tmp.size() - 1; i >= 0; i--) {
ans = ans + tmp[i];
}
LEN = tmp.size();
} else {
if (tmp.size() == LEN) {
string ss = "";
for (int i = tmp.size() - 1; i >= 0; i--) {
ss += tmp[i];
}
if (ss < ans) {
ans = ss;
}
}
}
}
return;
}
int main() {
int k;
cin >> n >> m >> k;
set<char> letter;
int sr, sc;
int er, ec;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
board[i][j] = s[j];
if (s[j] == 'S') {
sr = i;
sc = j;
}
if (s[j] == 'T') {
er = i;
ec = j;
}
if (s[j] != 'S' && s[j] != 'T') {
letter.insert(s[j]);
}
}
}
vector<char> grid;
for (set<char>::iterator it = letter.begin(); it != letter.end(); it++) {
grid.push_back(*it);
}
sort(grid.begin(), grid.end());
if (grid.size() < k) {
k = grid.size();
}
for (int kk = 0; kk < 8; kk += 2) {
int isr = sr + dir[kk];
int isc = sc + dir[kk + 1];
if (isr >= 0 && isr < n && isc >= 0 && isc < m) {
for (int ksize = 1; ksize <= k; ksize++) {
cnt = 0;
int a[26];
for (int j = 0; j < grid.size(); j++) {
a[j] = 0;
}
char cc = board[isr][isc];
int inum = -1;
for (int ii = 0; ii < grid.size(); ii++) {
if (grid[ii] == cc) {
inum = ii;
break;
}
}
a[inum] = 1;
nchoosek(0, a, ksize, grid.size(), 1, inum);
for (int i = 0; i < cnt; i = i + 1) {
for (int row = 0; row < n; row++) {
for (int col = 0; col < m; col++) {
if (board[row][col] == 'S') {
graph[row][col] = 'S';
}
if (board[row][col] == 'T') {
graph[row][col] = 'T';
}
if (board[row][col] != 'S' && board[row][col] != 'T') {
graph[row][col] = 'X';
for (int j = 0; j < ksize; j++) {
if (board[row][col] == grid[pattern[i][j]]) {
graph[row][col] = 'O';
}
}
}
}
}
for (int row = 0; row < n; row++) {
for (int col = 0; col < m; col++) {
node[row][col].visited = 0;
}
}
for (int row = 0; row < n; row++) {
for (int col = 0; col < m; col++) {
node[row][col].visited = 0;
}
}
BFS(isr, isc, er, ec);
}
}
}
}
if (LEN == 1E+9) {
if (n * m > 2) cout << "-1" << endl;
} else {
for (int i = 0; i < ans.size() - 1; i++) {
cout << ans[i];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int xs, ys, xt, yt;
int r, c, k, dist[55][55], ans, ok[30];
char mat[55][55];
bool help[55][55];
string str;
void solve() {
queue<pair<int, int> > q;
memset(dist, 0x3f3f3f3f, sizeof(dist));
dist[xt][yt] = 0;
q.push(pair<int, int>(xt, yt));
while (!q.empty()) {
int i = q.front().first, j = q.front().second;
q.pop();
if (i == xs && j == ys) break;
if (i && dist[i - 1][j] == 0x3f3f3f3f &&
(mat[i - 1][j] == 'S' || ok[mat[i - 1][j] - 'a'])) {
dist[i - 1][j] = dist[i][j] + 1;
q.push(pair<int, int>(i - 1, j));
}
if (i < r - 1 && dist[i + 1][j] == 0x3f3f3f3f &&
(mat[i + 1][j] == 'S' || ok[mat[i + 1][j] - 'a'])) {
dist[i + 1][j] = dist[i][j] + 1;
q.push(pair<int, int>(i + 1, j));
}
if (j && dist[i][j - 1] == 0x3f3f3f3f &&
(mat[i][j - 1] == 'S' || ok[mat[i][j - 1] - 'a'])) {
dist[i][j - 1] = dist[i][j] + 1;
q.push(pair<int, int>(i, j - 1));
}
if (j < c - 1 && dist[i][j + 1] == 0x3f3f3f3f &&
(mat[i][j + 1] == 'S' || ok[mat[i][j + 1] - 'a'])) {
dist[i][j + 1] = dist[i][j] + 1;
q.push(pair<int, int>(i, j + 1));
}
}
if (dist[xs][ys] == 0x3f3f3f3f || dist[xs][ys] > ans) return;
vector<pair<int, int> > curr, next;
char best, ch;
string s;
curr.push_back(pair<int, int>(xs, ys));
memset(help, false, sizeof(help));
for (int x = dist[xs][ys]; x > 0; x--) {
best = 'z' + 1;
for (int A = 0; A < curr.size(); A++) {
int i = curr[A].first, j = curr[A].second;
if (i && dist[i - 1][j] == x - 1 && !help[i - 1][j]) {
ch = mat[i - 1][j];
if (ch < best) {
best = ch;
next.clear();
next.push_back(pair<int, int>(i - 1, j));
help[i - 1][j] = true;
} else if (ch == best && !help[i - 1][j]) {
next.push_back(pair<int, int>(i - 1, j));
help[i - 1][j] = true;
}
}
if (i < r - 1 && dist[i + 1][j] == x - 1 && !help[i + 1][j]) {
ch = mat[i + 1][j];
if (ch < best) {
best = ch;
next.clear();
next.push_back(pair<int, int>(i + 1, j));
help[i + 1][j] = true;
} else if (ch == best && !help[i + 1][j]) {
next.push_back(pair<int, int>(i + 1, j));
help[i + 1][j] = true;
}
}
if (j && dist[i][j - 1] == x - 1 && !help[i][j - 1]) {
ch = mat[i][j - 1];
if (ch < best) {
best = ch;
next.clear();
next.push_back(pair<int, int>(i, j - 1));
help[i][j - 1] = true;
} else if (ch == best && !help[i][j - 1]) {
next.push_back(pair<int, int>(i, j - 1));
help[i][j - 1] = true;
}
}
if (j < c - 1 && dist[i][j + 1] == x - 1 && !help[i][j + 1]) {
ch = mat[i][j + 1];
if (ch < best) {
best = ch;
next.clear();
next.push_back(pair<int, int>(i, j + 1));
help[i][j + 1] = true;
} else if (ch == best && !help[i][j + 1]) {
next.push_back(pair<int, int>(i, j + 1));
help[i][j + 1] = true;
}
}
}
if (best != 'T') s.push_back(best);
curr.clear();
curr = next;
}
if (dist[xs][ys] < ans) {
ans = dist[xs][ys];
str = s;
} else if (dist[xs][ys] == ans && s < str)
str = s;
return;
}
void go(int x, int last) {
if (x == k) {
solve();
return;
}
for (int i = last + 1; i < 26; i++)
if (!ok[i]) {
ok[i] = 1;
go(x + 1, i);
ok[i] = 0;
}
return;
}
int main() {
cin >> r >> c >> k;
for (int i = 0; i < r; i++) cin >> mat[i];
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
if (mat[i][j] == 'S') {
xs = i;
ys = j;
} else if (mat[i][j] == 'T') {
xt = i;
yt = j;
}
}
ans = 0x3f3f3f3f;
memset(ok, 0, sizeof(ok));
go(0, -1);
if (ans == 0x3f3f3f3f)
cout << -1;
else
cout << str;
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 51;
const int maxm = 26;
const int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
struct Position {
int x, y;
};
Position st, en;
int n, m, k;
char mp[maxn][maxn];
bool hv[maxm], us[maxm];
int hc;
string ph, th;
int ml, tl;
int sd[maxn][maxn], ed[maxn][maxn];
queue<Position> qe;
bool Bound(Position p) { return p.x >= 0 && p.x < n && p.y >= 0 && p.y < m; }
void Bfs(Position s, int dis[maxn][maxn]) {
int i, j;
Position nw, nx;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) dis[i][j] = -1;
}
dis[s.x][s.y] = 0;
qe.push(s);
while (!qe.empty()) {
nw = qe.front();
qe.pop();
for (i = 0; i < 4; i++) {
nx.x = nw.x + dir[i][0];
nx.y = nw.y + dir[i][1];
if (Bound(nx) && dis[nx.x][nx.y] == -1) {
if (!(mp[nx.x][nx.y] >= 'a' && mp[nx.x][nx.y] <= 'z' &&
us[mp[nx.x][nx.y] - 'a'] == 0)) {
qe.push(nx);
dis[nx.x][nx.y] = dis[nw.x][nw.y] + 1;
}
}
}
}
}
void FindPath() {
vector<Position> tmp;
Position nw, nx;
char mi = 'z' + 1;
int step = 1;
int i;
qe.push(st);
while (!qe.empty()) {
nw = qe.front();
qe.pop();
for (i = 0; i < 4; i++) {
nx.x = nw.x + dir[i][0];
nx.y = nw.y + dir[i][1];
if (Bound(nx) && sd[nx.x][nx.y] == step &&
sd[nx.x][nx.y] + ed[nx.x][nx.y] == tl) {
sd[nx.x][nx.y] = -1;
if (mp[nx.x][nx.y] < mi) {
mi = mp[nx.x][nx.y];
tmp.clear();
tmp.push_back(nx);
} else if (mp[nx.x][nx.y] == mi) {
tmp.push_back(nx);
}
}
}
if (qe.empty()) {
if (tmp.empty()) break;
while (!tmp.empty()) {
qe.push(tmp.back());
tmp.pop_back();
}
if (mi != 'T') th += mi;
mi = 'z' + 1;
step++;
}
}
}
void Run() {
tl = -1;
th = "";
Bfs(st, sd);
Bfs(en, ed);
if (sd[en.x][en.y] == -1) return;
tl = sd[en.x][en.y];
FindPath();
if (ml == -1 || ml > tl || (ml == tl && ph > th)) {
ml = tl;
ph = th;
}
}
void Select(int xp, int au) {
if (au >= k) {
Run();
return;
}
if (xp >= maxm) {
return;
}
if (hv[xp]) {
us[xp] = 1;
Select(xp + 1, au + 1);
us[xp] = 0;
}
Select(xp + 1, au);
}
int main() {
int i, j;
while (cin >> n >> m >> k) {
for (i = 0; i < n; i++) cin >> mp[i];
memset(hv, 0, sizeof(hv));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (mp[i][j] >= 'a' && mp[i][j] <= 'z')
hv[mp[i][j] - 'a'] = 1;
else if (mp[i][j] == 'S')
st.x = i, st.y = j;
else if (mp[i][j] == 'T')
en.x = i, en.y = j;
}
}
hc = 0;
for (i = 0; i < maxm; i++)
if (hv[i]) hc++;
ml = -1;
ph = "";
if (k >= hc) {
for (i = 0; i < maxm; i++) us[i] = 1;
Run();
} else {
memset(us, 0, sizeof(us));
Select(0, 0);
}
if (ml == -1)
cout << "-1" << endl;
else
cout << ph << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf(1010101010);
const int dy[4] = {0, -1, 0, 1};
const int dx[4] = {1, 0, -1, 0};
string bin(int x, int le) {
string ret;
for (int i(0); i < (le); i++) ret += '0' + (x % 2), x /= 2;
reverse((ret).begin(), (ret).end());
return ret;
}
int h, w;
vector<string> veld(50);
typedef int Mat[50][50];
Mat ds, dt;
inline bool outofbounds(int y, int x) {
return y >= h || y < 0 || x >= w || x < 0;
}
inline bool ok(char ch, int bm) {
return ch == 'S' || ch == 'T' || bm & (1 << (ch - 'a'));
}
void bfs(int bm, pair<int, int> src, Mat& d) {
for (int i(0); i < (h); i++)
for (int j(0); j < (w); j++) d[i][j] = inf;
d[src.first][src.second] = 0;
deque<pair<int, int> > q;
for (int i(0); i < (h); i++)
for (int j(0); j < (w); j++) q.push_back(src);
while (((int)(q).size())) {
int y1(q.front().first), x1(q.front().second);
q.pop_front();
for (int dir(0); dir < (4); dir++) {
int y2(y1 + dy[dir]), x2(x1 + dx[dir]);
if (!outofbounds(y2, x2) && (ok(veld[y2][x2], bm))) {
int d2(d[y1][x1] + 1);
if (d2 < d[y2][x2]) {
d[y2][x2] = d2;
q.push_back(make_pair(y2, x2));
}
}
}
}
}
bool seen[55][55];
string bfs(int bm) {
pair<int, int> s, t;
for (int i(0); i < (h); i++)
for (int j(0); j < (w); j++) {
if (veld[i][j] == 'S') s = make_pair(i, j);
if (veld[i][j] == 'T') t = make_pair(i, j);
}
bfs(bm, s, ds), bfs(bm, t, dt);
int the_d(ds[t.first][t.second]);
if (the_d == inf) {
string ret;
ret += 'z' + 1;
return ret;
}
string pad;
vector<pair<int, int> > doetmee;
doetmee.push_back(s);
for (int i(0); i < (50); i++)
for (int j(0); j < (50); j++) seen[i][j] = false;
seen[s.first][s.second] = true;
while (true) {
vector<pair<int, int> > doetmee2;
assert(!((int)(doetmee2).size()));
char nxt_chr('z');
for (__typeof((doetmee).end()) it((doetmee).begin()); it != (doetmee).end();
++it) {
int y1((*it).first), x1((*it).second);
for (int dir(0); dir < (4); dir++) {
int y2(y1 + dy[dir]), x2(x1 + dx[dir]);
if (outofbounds(y2, x2)) continue;
if (ds[y1][x1] + 1 + dt[y2][x2] == the_d) {
if (y2 == t.first && x2 == t.second) {
return pad;
}
nxt_chr = min(nxt_chr, veld[y2][x2]);
doetmee2.push_back(make_pair(y2, x2));
}
}
}
pad += nxt_chr;
doetmee.clear();
for (__typeof((doetmee2).end()) it((doetmee2).begin());
it != (doetmee2).end(); ++it) {
int y((*it).first), x((*it).second);
if (veld[y][x] == nxt_chr) {
if (!seen[y][x]) {
doetmee.push_back(*it);
seen[y][x] = true;
}
}
}
}
}
string min1(string const& a, string const& b) {
if (((int)(a).size()) < ((int)(b).size())) return a;
if (((int)(a).size()) > ((int)(b).size())) return b;
return min(a, b);
}
int main() {
int k;
cin >> h >> w >> k;
for (int i(0); i < (h); i++) cin >> veld[i];
string opt;
for (int i(0); i < (1000); i++) opt += 'a';
const int A(26);
for (int bm(0); bm < (1 << (A));) {
if (__builtin_popcount(bm) < k)
bm++;
else {
string ans(bfs(bm));
if (ans[0] != 'z' + 1) opt = min1(opt, ans);
bm += bm & -bm;
}
}
if (((int)(opt).size()) == 1000) {
puts("-1");
} else {
cout << opt << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
int size(T& a) {
return (int)a.size();
}
const int MAXN = 51;
const int INF = 1000000000;
char s[MAXN][MAXN];
bool can[26];
int n, m, k;
int sx, sy, fx, fy;
int d[MAXN][MAXN];
bool used[MAXN][MAXN];
deque<pair<int, int> > Q;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
bool valid(int y, int x) {
return x >= 0 && y >= 0 && x < m && y < n &&
(s[y][x] == 'T' || s[y][x] == 'S' || can[s[y][x] - 'a']) &&
d[y][x] == INF;
}
struct Qu {
int qx[MAXN * MAXN * 10];
int qy[MAXN * MAXN * 10];
int head;
Qu() { head = 0; }
void clear() { head = 0; }
void operator=(const Qu& que) {
head = que.head;
for (int i = (0); i < (head); ++i) qx[i] = que.qx[i], qy[i] = que.qy[i];
}
void push(int x, int y) {
qx[head] = x;
qy[head] = y;
head++;
}
int size() { return head; }
};
Qu cur, nxt;
int ans = INF;
string res = "";
void brute(int pos, int take) {
if (pos == 26) {
Q.clear();
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) d[i][j] = INF;
d[fy][fx] = 0;
Q.push_back(make_pair(fy, fx));
while (size(Q) > 0) {
pair<int, int> p = Q.front();
Q.pop_front();
for (int u = (0); u < (4); ++u)
if (valid(p.first + dy[u], p.second + dx[u])) {
Q.push_back(make_pair(p.first + dy[u], p.second + dx[u]));
d[p.first + dy[u]][p.second + dx[u]] = d[p.first][p.second] + 1;
}
}
if (d[sy][sx] == INF) return;
string path = "";
cur.push(sx, sy);
memset((used), (false), sizeof(used));
while (size(cur) > 0) {
int minSymbol = INF;
for (int i = (0); i < (size(cur)); ++i) {
int x = cur.qx[i];
int y = cur.qy[i];
for (int u = (0); u < (4); ++u) {
int nx = x + dx[u];
int ny = y + dy[u];
if (nx >= 0 && ny >= 0 && nx < m && ny < n &&
d[ny][nx] == d[y][x] - 1 &&
(s[ny][nx] == 'S' || s[ny][nx] == 'T' || can[s[ny][nx] - 'a'])) {
minSymbol = min(minSymbol, (int)s[ny][nx]);
}
}
}
nxt.clear();
if (minSymbol != 'T') path += (char)(minSymbol);
for (int i = (0); i < (size(cur)); ++i) {
int x = cur.qx[i];
int y = cur.qy[i];
for (int u = (0); u < (4); ++u) {
int nx = x + dx[u];
int ny = y + dy[u];
if (nx >= 0 && ny >= 0 && nx < m && ny < n &&
d[ny][nx] == d[y][x] - 1 &&
(s[ny][nx] == 'S' || s[ny][nx] == 'T' || can[s[ny][nx] - 'a']) &&
s[ny][nx] == minSymbol && !used[ny][nx]) {
nxt.push(nx, ny);
used[ny][nx] = true;
}
}
}
cur = nxt;
}
if (ans > d[sy][sx] || (ans == d[sy][sx] && res > path)) {
ans = d[sy][sx];
res = path;
}
} else {
if (take > 0) {
can[pos] = true;
brute(pos + 1, take - 1);
}
can[pos] = false;
brute(pos + 1, take);
}
}
void solve() {
scanf("%d%d%d\n", &n, &m, &k);
for (int i = (0); i < (n); ++i) {
gets(s[i]);
for (int j = (0); j < (m); ++j)
if (s[i][j] == 'S')
sx = j, sy = i;
else if (s[i][j] == 'T')
fx = j, fy = i;
}
brute(0, k);
if (ans == INF)
cout << "-1";
else
printf("%s", res.c_str());
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int R, C, K, SX, SY, TX, TY;
string grid[60], best;
int dist[60][60];
vector<int> dir[60][60];
bool can[26];
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
bool mark[60][60];
void bfs() {
memset(dist, oo, sizeof(dist));
for (int i = (0); i < (R); i++)
for (int j = (0); j < (C); j++) dir[i][j].clear();
dist[TX][TY] = 0;
queue<pair<int, int> > q;
q.push(pair<int, int>(TX, TY));
while (!q.empty()) {
int r = q.front().first, c = q.front().second;
q.pop();
if (grid[r][c] == 'S') break;
for (int i = (0); i < (4); i++) {
int rr = r + dx[i], cc = c + dy[i];
if (rr < 0 || rr == R || cc < 0 || cc == C) continue;
if (grid[rr][cc] != 'S' && grid[rr][cc] != 'T' &&
!can[grid[rr][cc] - 'a'])
continue;
if (dist[rr][cc] < dist[r][c] + 1) continue;
if (dist[rr][cc] > dist[r][c] + 1) {
dist[rr][cc] = dist[r][c] + 1;
dir[rr][cc].clear();
dir[rr][cc].push_back((i + 2) % 4);
q.push(pair<int, int>(rr, cc));
} else {
char ch = grid[rr + dx[dir[rr][cc][0]]][cc + dy[dir[rr][cc][0]]];
if (ch < grid[r][c]) continue;
if (ch > grid[r][c]) dir[rr][cc].clear();
dir[rr][cc].push_back((i + 2) % 4);
}
}
}
if (dist[SX][SY] == oo) return;
if (best != "0" && int((best).size()) < dist[SX][SY] - 1) return;
string cur(dist[SX][SY] - 1, 'z');
vector<pair<int, int> > level;
level.push_back(pair<int, int>(SX, SY));
memset(mark, 0, sizeof(mark));
mark[SX][SY] = true;
for (int i = (0); i < (dist[SX][SY] - 1); i++) {
for (int j = (0); j < (int((level).size())); j++) {
int r = level[j].first, c = level[j].second;
cur[i] = min(cur[i], grid[r + dx[dir[r][c][0]]][c + dy[dir[r][c][0]]]);
}
vector<pair<int, int> > nxt;
for (int j = (0); j < (int((level).size())); j++) {
int r = level[j].first, c = level[j].second;
if (cur[i] != grid[r + dx[dir[r][c][0]]][c + dy[dir[r][c][0]]]) continue;
for (int k = (0); k < (int((dir[r][c]).size())); k++) {
int rr = r + dx[dir[r][c][k]], cc = c + dy[dir[r][c][k]];
if (!mark[rr][cc]) {
mark[rr][cc] = true;
nxt.push_back(pair<int, int>(rr, cc));
}
}
}
level = nxt;
}
if (best == "0" || int((cur).size()) < int((best).size()) ||
(int((cur).size()) == int((best).size()) && cur < best))
best = cur;
}
void rek(int p, int k) {
if (k < 0) return;
if (p == 26) {
if (k) return;
bfs();
} else {
can[p] = false;
rek(p + 1, k);
can[p] = true;
rek(p + 1, k - 1);
}
}
int main() {
cin >> R >> C >> K;
for (int i = (0); i < (R); i++) cin >> grid[i];
for (int i = (0); i < (R); i++)
for (int j = (0); j < (C); j++) {
if (grid[i][j] == 'S') {
SX = i;
SY = j;
}
if (grid[i][j] == 'T') {
TX = i;
TY = j;
}
}
best = "0";
rek(0, K);
if (best == "0") {
cout << -1 << endl;
} else {
cout << best << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char in[55][55];
int used[300];
char ap[100], apc;
string ans;
int sx, sy;
int ex, ey;
int all[300], ac;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int que[3000][2];
int vis[55][55];
int dis[55][55];
int visid;
vector<pair<int, int> > pos[2000];
inline void solve() {
int i, j;
visid++;
int qs = 0, qe = 0;
que[qe][0] = sx;
que[qe][1] = sy;
qe++;
vis[sx][sy] = visid;
dis[sx][sy] = 0;
while (qs < qe) {
int x = que[qs][0], y = que[qs][1];
qs++;
for (i = 0; i < ac; i++) {
for (j = 0; j < 4; j++) {
int xx = x + dx[j], yy = y + dy[j];
if (xx >= 0 && xx < n && yy >= 0 && yy < m && vis[xx][yy] != visid &&
in[xx][yy] == all[i]) {
que[qe][0] = xx;
que[qe][1] = yy;
qe++;
vis[xx][yy] = visid;
dis[xx][yy] = dis[x][y] + 1;
}
}
}
for (j = 0; j < 4; j++) {
int xx = x + dx[j], yy = y + dy[j];
if (xx >= 0 && xx < n && yy >= 0 && yy < m && vis[xx][yy] != visid &&
in[xx][yy] == 'S') {
que[qe][0] = xx;
que[qe][1] = yy;
qe++;
vis[xx][yy] = visid;
dis[xx][yy] = dis[x][y] + 1;
}
}
}
if (vis[ex][ey] != visid) return;
string str;
int d = dis[ex][ey];
pos[d].clear();
pos[d].push_back(make_pair(ex, ey));
visid++;
vis[ex][ey] = visid;
while (d > 1) {
char c = 'z' + 1;
for (i = 0; i < pos[d].size(); i++) {
int x = pos[d][i].first, y = pos[d][i].second;
for (j = 0; j < 4; j++) {
int xx = x + dx[j], yy = y + dy[j];
if (xx >= 0 && xx < n && yy >= 0 && yy < m &&
vis[xx][yy] == visid - 1 && dis[xx][yy] == dis[x][y] - 1) {
vis[xx][yy] = visid;
if (in[xx][yy] < c) {
c = in[xx][yy];
pos[d - 1].clear();
}
if (in[xx][yy] == c) {
pos[d - 1].push_back(make_pair(xx, yy));
}
}
}
}
str += c;
d--;
}
if (str.size() < ans.size() || (str.size() == ans.size() && str < ans))
ans = str;
}
inline void dfs(int np, int c) {
solve();
if (np == apc) return;
dfs(np + 1, c);
if (c < k) {
all[ac++] = ap[np];
dfs(np + 1, c + 1);
ac--;
}
}
int main() {
int i, j;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) scanf("%s", in[i]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
if (in[i][j] == 'S') ex = i, ey = j;
if (in[i][j] == 'T') sx = i, sy = j;
used[in[i][j]] = 1;
}
for (i = 'a'; i <= 'z'; i++)
if (used[i]) ap[apc++] = i;
for (int i = 0; i < 1000; i++) ans += 'z';
dfs(0, 0);
if (ans.size() == 1000)
puts("-1");
else
puts(ans.c_str());
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(55);
struct nnode {
int x, y, d;
string s;
nnode(){};
nnode(int x, int y, int d, string s) : x(x), y(y), d(d), s(s){};
bool operator<(const nnode &other) const {
if (d != other.d) return d > other.d;
return s > other.s;
}
};
char a[MAXN][MAXN];
int n, m, k, path[MAXN][MAXN], available[26], ans;
int d[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
pair<int, int> q[MAXN * MAXN];
string ansPath, p[MAXN][MAXN];
void SSSP() {
int fr = 0, bk = 0;
pair<int, int> s, t;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
path[i][j] = INF;
p[i][j] = "";
if (a[i][j] == 'S') {
s = pair<int, int>(i, j);
} else if (a[i][j] == 'T') {
t = pair<int, int>(i, j);
q[bk++] = t;
path[t.first][t.second] = 0;
}
}
vector<pair<int, int> > b;
while (fr != bk) {
int x = q[fr].first, y = q[fr].second;
fr++;
b.push_back(pair<int, int>(x, y));
if (a[x][y] == 'S') break;
for (int i = 0; i < 4; i++) {
int tx = x + d[i][0];
int ty = y + d[i][1];
if (tx < 0 || tx >= n || ty < 0 || ty >= m) continue;
if (a[tx][ty] == 'T') continue;
if (a[tx][ty] != 'S' && !available[a[tx][ty] - 'a']) continue;
if (path[x][y] + 1 < path[tx][ty]) {
q[bk++] = pair<int, int>(tx, ty);
path[tx][ty] = path[x][y] + 1;
}
}
}
if (path[s.first][s.second] == INF) return;
p[s.first][s.second] = "S";
for (int i = (int)b.size() - 1; i >= 0; i--) {
int x = b[i].first, y = b[i].second;
if (p[s.first][s.second] == "") continue;
for (int j = 0; j < 4; j++) {
int tx = x + d[j][0];
int ty = y + d[j][1];
if (tx < 0 || tx >= n || ty < 0 || ty >= m) continue;
if (path[x][y] - 1 == path[tx][ty]) {
if (p[tx][ty] == "")
p[tx][ty] = p[x][y] + a[tx][ty];
else
p[tx][ty] = min(p[tx][ty], p[x][y] + a[tx][ty]);
}
}
}
if (path[s.first][s.second] < ans ||
(path[s.first][s.second] == ans && p[t.first][t.second] < ansPath)) {
ans = path[s.first][s.second];
ansPath = p[t.first][t.second];
}
}
void combination(int now, int i) {
if (now == k) {
SSSP();
return;
}
while (i < 26) {
available[i] = 1;
combination(now + 1, i + 1);
available[i] = 0;
i++;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", a[i]);
ans = INF;
ansPath = "";
combination(0, -1);
if (ans == INF)
printf("-1");
else
cout << ansPath.substr(1, ansPath.size() - 2);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int GetBit(int mask, int num) { return (mask >> num) & 1; }
inline int GetAmountOfBits(int mask) {
int ans = 0;
while (mask > 0) {
ans += (mask & 1);
mask >>= 1;
}
return ans;
}
const int kAlphabetSize = 26;
const int kDx[4] = {-1, 0, 0, 1};
const int kDy[4] = {0, -1, 1, 0};
int n, m, k;
vector<vector<char> > field;
int si, sj;
int fi, fj;
bool ans_found;
int ans_len;
string ans_path;
vector<vector<bool> > used;
vector<vector<bool> > inused;
vector<vector<int> > dist;
vector<int> char_posses_i[kAlphabetSize];
vector<int> char_posses_j[kAlphabetSize];
void ClearUsed(int mask, vector<vector<bool> >& used) {
for (int c = 0; c < kAlphabetSize; ++c) {
if (!GetBit(mask, c)) {
continue;
}
for (int i = 0; i < (int)char_posses_i[c].size(); ++i) {
used[char_posses_i[c][i]][char_posses_j[c][i]] = false;
}
}
used[si][sj] = false;
used[fi][fj] = false;
}
void UpdateAns(int mask) {
if (dist[fi][fj] == 1) {
ans_found = true;
ans_len = 1;
ans_path = "";
return;
}
string cur_path;
cur_path.reserve(dist[fi][fj] - 1);
deque<int> qi;
deque<int> qj;
qi.push_back(fi);
qj.push_back(fj);
inused[fi][fj] = true;
while (!qi.empty()) {
int ci = qi.front();
qi.pop_front();
int cj = qj.front();
qj.pop_front();
for (int step_index = 0; step_index < 4; ++step_index) {
int ni = ci + kDx[step_index];
int nj = cj + kDy[step_index];
if (ni >= 0 && ni < n && nj >= 0 && nj < m && !inused[ni][nj] &&
used[ni][nj] && dist[ni][nj] + 1 == dist[ci][cj]) {
inused[ni][nj] = true;
qi.push_back(ni);
qj.push_back(nj);
}
}
}
qi.push_back(si);
qj.push_back(sj);
used[si][sj] = false;
while (!qi.empty()) {
char min_char = field[qi[0]][qj[0]];
for (int i = 1; i < (int)qi.size(); ++i) {
min_char = min(min_char, field[qi[i]][qj[i]]);
}
if (min_char != 'S' && min_char != 'T') {
cur_path.push_back(min_char);
}
int sz = qi.size();
for (int itr = 0; itr < (int)sz; ++itr) {
int ci = qi.front();
qi.pop_front();
int cj = qj.front();
qj.pop_front();
if (field[ci][cj] != min_char) {
continue;
}
for (int step_index = 0; step_index < 4; ++step_index) {
int ni = ci + kDx[step_index];
int nj = cj + kDy[step_index];
if (ni >= 0 && ni < n && nj >= 0 && nj < m && inused[ni][nj] &&
used[ni][nj] && dist[ni][nj] == dist[ci][cj] + 1) {
used[ni][nj] = false;
qi.push_back(ni);
qj.push_back(nj);
}
}
}
}
ClearUsed(mask, inused);
if (!ans_found || dist[fi][fj] < ans_len || cur_path < ans_path) {
ans_found = true;
ans_len = dist[fi][fj];
ans_path = cur_path;
}
}
void Solve(int mask) {
queue<int> qi;
queue<int> qj;
used[si][sj] = true;
dist[si][sj] = 0;
qi.push(si);
qj.push(sj);
while (!qi.empty()) {
int ci = qi.front();
qi.pop();
int cj = qj.front();
qj.pop();
for (int step_index = 0; step_index < 4; ++step_index) {
int ni = ci + kDx[step_index];
int nj = cj + kDy[step_index];
if (ni >= 0 && ni < n && nj >= 0 && nj < m &&
(field[ni][nj] == 'T' || field[ni][nj] == 'S' ||
GetBit(mask, field[ni][nj] - 'a')) &&
!used[ni][nj]) {
used[ni][nj] = true;
dist[ni][nj] = dist[ci][cj] + 1;
qi.push(ni);
qj.push(nj);
}
}
}
if (used[fi][fj]) {
if (!ans_found || dist[fi][fj] <= ans_len) {
UpdateAns(mask);
}
}
ClearUsed(mask, used);
}
void Dfs(int c, int mask, int num) {
if (c == kAlphabetSize) {
Solve(mask);
return;
}
if (num + 1 <= k) {
Dfs(c + 1, mask + (1 << c), num + 1);
}
Dfs(c + 1, mask, num);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> k;
field.resize(n, vector<char>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> field[i][j];
if (field[i][j] == 'S') {
si = i;
sj = j;
}
if (field[i][j] == 'T') {
fi = i;
fj = j;
}
}
}
used.assign(n, vector<bool>(m, false));
inused.assign(n, vector<bool>(m, false));
dist.resize(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (field[i][j] >= 'a' && field[i][j] <= 'z') {
char_posses_i[field[i][j] - 'a'].push_back(i);
char_posses_j[field[i][j] - 'a'].push_back(j);
}
}
}
ans_found = false;
Dfs(0, 0, 0);
if (!ans_found) {
cout << -1 << endl;
} else {
cout << ans_path << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, S, T;
char s[2555];
vector<int> adj[2555];
int val[2555], d[2555], p[2555];
string ans;
void check(int x) {
string now;
for (; d[x]; x = p[x]) now += s[x];
reverse(now.begin(), now.end());
if (now.length() < ans.length())
ans = now;
else if (now.length() == ans.length() && now < ans)
ans = now;
}
bool cmp_val(int i, int j) { return val[i] < val[j]; }
void solve(int mask) {
memset(d, -1, sizeof d);
vector<int> u, v;
d[S] = 0, val[S] = 0, u.push_back(S);
while (!u.empty()) {
v.clear();
for (int i = 0; i < u.size(); i++) {
int x = u[i];
for (int j = 0; j < adj[x].size(); j++) {
int y = adj[x][j];
if (y == T) {
check(x);
return;
}
if (d[y] != -1 || !(mask >> (s[y] - 'a') & 1)) continue;
d[y] = d[x] + 1, p[y] = x, val[y] = val[x] * 2555 + s[y],
v.push_back(y);
}
}
sort(v.begin(), v.end(), cmp_val);
for (int i = 0, prv; i < v.size(); i++) {
if (i == 0)
prv = val[v[0]], val[v[0]] = 0;
else {
int tmp = val[v[i]];
val[v[i]] = val[v[i - 1]] + (tmp != prv);
prv = tmp;
}
}
u = v;
}
}
bool good(int i, int j) { return 0 <= i && i < n && 0 <= j && j < m; }
int node(int i, int j) { return i * m + j; }
bool cmp_s(int i, int j) { return s[i] < s[j]; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", s + i * m);
ans = string(3000, 'a');
for (int i = 0; i < n * m; i++) {
if (s[i] == 'S') S = i;
if (s[i] == 'T') T = i;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (good(i + 1, j)) adj[node(i, j)].push_back(node(i + 1, j));
if (good(i - 1, j)) adj[node(i, j)].push_back(node(i - 1, j));
if (good(i, j + 1)) adj[node(i, j)].push_back(node(i, j + 1));
if (good(i, j - 1)) adj[node(i, j)].push_back(node(i, j - 1));
}
for (int i = 0; i < n * m; i++) sort(adj[i].begin(), adj[i].end(), cmp_s);
for (int i = 0; i < (1 << 26); i++)
if (__builtin_popcount(i) == k) solve(i);
if (ans.length() == 3000) ans = "-1";
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int MAXN = 55;
struct Node {
int sta, pos;
string path;
Node(string _path, int _sta, int _pos) : path(_path), sta(_sta), pos(_pos) {}
bool operator<(const Node& v) const {
int len = path.size();
int lenb = v.path.size();
if (len != lenb) return len > lenb;
if (path < v.path) return false;
if (path > v.path) return true;
return pos < v.pos;
}
};
int n, m, K;
int si, sj;
static int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
char mat[MAXN][MAXN];
int visited[MAXN][MAXN];
set<long long> s;
void InputMat() {
for (int i = 0; i < n; i++) {
while (getchar() != '\n')
;
for (int j = 0; j < m; j++) {
mat[i][j] = getchar();
if (mat[i][j] == 'S') {
si = i;
sj = j;
}
}
}
}
int iCount(int x) {
int ret = 0;
for (; x; x &= x - 1) ret++;
return ret;
}
bool legal(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && mat[x][y] != 'S';
}
string Bfs() {
priority_queue<Node> q;
memset(visited, 0, sizeof(visited));
s.clear();
q.push(Node("", 0, si * m + sj));
s.insert(si * m + sj);
while (!q.empty()) {
Node u = q.top();
q.pop();
for (int k = 0; k < 4; k++) {
int nx = u.pos / m + dir[k][0];
int ny = u.pos % m + dir[k][1];
if (legal(nx, ny) == false) continue;
if (mat[nx][ny] == 'T') {
return u.path;
}
if (!(u.sta & (1 << (mat[nx][ny] - 'a'))) && iCount(u.sta) == K) continue;
Node v = Node(u.path + mat[nx][ny], u.sta | (1 << (mat[nx][ny] - 'a')),
nx * m + ny);
long long tmp = v.sta * 10000 + v.pos;
if (s.find(tmp) != s.end()) continue;
if (visited[nx][ny] && (visited[nx][ny] & v.sta) == visited[nx][ny])
continue;
visited[nx][ny] = v.sta;
s.insert(tmp);
q.push(v);
}
}
return "-1";
}
int main() {
string Ans;
scanf("%d %d %d", &n, &m, &K);
InputMat();
Ans = Bfs();
printf("%s\n", Ans.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55, dx[4] = {0, 0, -1, 1}, dy[4] = {1, -1, 0, 0};
int n, m, k, dis[MAXN][MAXN], sx, sy, tx, ty;
queue<pair<int, int> > S;
char mp[MAXN][MAXN];
string ans, res;
bool r[27], o;
bool isval(int x, int y) { return x < n && y < m && x >= 0 && y >= 0; }
void BFS(vector<pair<int, int> > w) {
vector<pair<int, int> > rx[27];
for (int ii = 0; ii < w.size(); ii++) {
int x = w[ii].first, y = w[ii].second;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (!isval(nx, ny) || (!r[mp[nx][ny] - 'a'] && mp[nx][ny] != 'T') ||
dis[nx][ny] + 1 != dis[x][y])
continue;
if (mp[nx][ny] == 'T') return;
rx[mp[nx][ny] - 'a'].push_back({nx, ny});
}
}
for (int i = 0; i < 27; i++) {
sort(rx[i].begin(), rx[i].end());
rx[i].resize(unique(rx[i].begin(), rx[i].end()) - rx[i].begin());
if (rx[i].size() == 0) continue;
BFS(rx[i]);
res += (char)('a' + i);
return;
}
}
void solve() {
res.clear();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) dis[i][j] = -1;
S.push({tx, ty});
dis[tx][ty] = 0;
while (!S.empty()) {
pair<int, int> c = S.front();
S.pop();
for (int i = 0; i < 4; i++) {
int nx = c.first + dx[i], ny = c.second + dy[i];
if (!isval(nx, ny) ||
(mp[nx][ny] != 'S' && mp[nx][ny] != 'T' && !r[mp[nx][ny] - 'a']))
continue;
if (dis[nx][ny] == -1) {
S.push({nx, ny});
dis[nx][ny] = dis[c.first][c.second] + 1;
}
}
}
if (dis[sx][sy] == -1) return;
vector<pair<int, int> > vc;
vc.push_back({sx, sy});
BFS(vc);
reverse(res.begin(), res.end());
if (!o)
ans = res, o = 1;
else {
if (ans.size() < res.size()) return;
if (ans.size() > res.size())
ans = res;
else
ans = min(ans, res);
}
}
void bt(int ind, int rem) {
if (ind == 26) {
solve();
return;
}
if (rem > 0) {
r[ind] = 1;
bt(ind + 1, rem - 1);
}
r[ind] = 0;
bt(ind + 1, rem);
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> mp[i][j];
if (mp[i][j] == 'S')
sx = i, sy = j;
else if (mp[i][j] == 'T')
tx = i, ty = j;
}
bt(0, k);
if (!o)
cout << -1 << endl;
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char A[53][53];
int q[(4 * 15000)];
int dist[53][53];
int dr[] = {-1, 0, 0, 1};
int dc[] = {0, -1, 1, 0};
int sz(int s) {
int ans = 0;
while (s) ans += s & 1, s >>= 1;
return ans;
}
int N, M, K;
bool marked[53][53];
void mark(int i, int j) {
if (marked[i][j]) return;
marked[i][j] = true;
for (int mv = 0; mv < (4); ++mv) {
int i2 = i + dr[mv];
int j2 = j + dc[mv];
if (i2 < 0 || i2 >= N) continue;
if (j2 < 0 || j2 >= M) continue;
if (marked[i2][j2]) continue;
if (dist[i2][j2] < 0) continue;
if (dist[i2][j2] == dist[i][j] - 1) mark(i2, j2);
}
}
int main() {
cin >> N >> M >> K;
for (int i = 0; i < (N); ++i) scanf("%s", A[i]);
int seen = 0;
int ti = -1, tj = -1;
int si = -1, sj = -1;
for (int i = 0; i < (N); ++i)
for (int j = 0; j < (M); ++j)
if (A[i][j] == 'T')
ti = i, tj = j;
else if (A[i][j] == 'S')
si = i, sj = j;
else
seen |= 1 << (A[i][j] - 'a');
assert(si >= 0 && sj >= 0);
assert(ti >= 0 && tj >= 0);
int h = 0, t = -1;
int S = 1 << 26;
for (int s = 0; s < (S); ++s) {
if ((s | seen) > seen) continue;
if (sz(s) > K) continue;
q[++t] = s;
assert(t < (4 * 15000));
}
string ans(N * M + 1, 'z');
while (h <= t) {
int s = q[h++];
queue<int> Q;
Q.push(((si)*50 + (sj)));
memset(dist, -1, sizeof(dist));
dist[si][sj] = 0;
while (!Q.empty()) {
int n = Q.front();
Q.pop();
int i = ((n) / 50), j = ((n) % 50);
if (i == ti && j == tj) break;
assert(dist[i][j] >= 0);
for (int mv = 0; mv < (4); ++mv) {
int i2 = i + dr[mv];
int j2 = j + dc[mv];
if (i2 < 0 || i2 >= N) continue;
if (j2 < 0 || j2 >= M) continue;
if (A[i2][j2] != 'T' && !(s & (1 << (A[i2][j2] - 'a')))) continue;
if (dist[i2][j2] < 0 || dist[i][j] + 1 < dist[i2][j2]) {
dist[i2][j2] = dist[i][j] + 1;
Q.push(((i2)*50 + (j2)));
}
}
}
if (dist[ti][tj] < 0 || dist[ti][tj] > (int)ans.size() + 1) continue;
memset(marked, 0, sizeof(marked));
mark(ti, tj);
vector<int> now;
vector<int> next;
string path;
char nextc;
now.push_back(((si)*50 + (sj)));
while (!now.empty()) {
next.clear();
nextc = 'z' + 1;
int m = now.size();
for (int x = 0; x < (m); ++x) {
int n = now[x];
int i = ((n) / 50), j = ((n) % 50);
for (int mv = 0; mv < (4); ++mv) {
int i2 = i + dr[mv];
int j2 = j + dc[mv];
if (i2 < 0 || i2 >= N) continue;
if (j2 < 0 || j2 >= M) continue;
if (!marked[i2][j2]) continue;
if (dist[i2][j2] != dist[i][j] + 1) continue;
char c = A[i2][j2];
if (c < nextc) nextc = c;
}
}
for (int x = 0; x < (m); ++x) {
int n = now[x];
int i = ((n) / 50), j = ((n) % 50);
for (int mv = 0; mv < (4); ++mv) {
int i2 = i + dr[mv];
int j2 = j + dc[mv];
if (i2 < 0 || i2 >= N) continue;
if (j2 < 0 || j2 >= M) continue;
if (!marked[i2][j2]) continue;
if (dist[i2][j2] != dist[i][j] + 1) continue;
char c = A[i2][j2];
if (c != nextc) continue;
next.push_back(((i2)*50 + (j2)));
}
}
sort(next.begin(), next.end());
next.erase(unique(next.begin(), next.end()), next.end());
swap(now, next);
if (!now.empty()) path += nextc;
}
assert((int)path.length() == dist[ti][tj] && dist[ti][tj] >= 1);
path = path.substr(0, dist[ti][tj] - 1);
if (path.length() < ans.length() ||
(path.length() == ans.length() && path < ans)) {
ans = path;
}
}
if ((int)ans.length() <= N * M)
cout << ans << endl;
else
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int cnt = 1, key, prior;
long long sum[5] = {};
Node *left = NULL, *right = NULL;
};
typedef Node *PNode;
Node nodes[111111];
int pri[111111];
int nodeCount = 0;
inline int cnt(PNode &v) { return v ? v->cnt : 0; }
inline void update(PNode &v) {
if (v) {
v->cnt = cnt(v->left) + cnt(v->right) + 1;
int off = 0;
if (v->left) {
for (int i = 0; i < (int)(5); ++i) v->sum[i] = v->left->sum[i];
off = v->left->cnt % 5;
} else {
for (int i = 0; i < (int)(5); ++i) v->sum[i] = 0;
}
v->sum[off] += v->key;
if (++off == 5) off = 0;
if (v->right) {
for (int i = 0; i < (int)(5); ++i) {
int ii = i + off;
if (ii >= 5) ii -= 5;
v->sum[ii] += v->right->sum[i];
}
}
}
}
void merge(PNode l, PNode r, PNode &t) {
if (!l || !r) {
t = l ? l : r;
return;
}
if (l->prior > r->prior) {
merge(l->right, r, l->right);
t = l;
} else {
merge(l, r->left, r->left);
t = r;
}
update(t);
}
void split(PNode t, PNode &l, PNode &r, int key) {
if (!t) {
l = r = NULL;
return;
}
if (key < t->key) {
split(t->left, l, t->left, key);
r = t;
} else {
split(t->right, t->right, r, key);
l = t;
}
update(t);
}
PNode root = NULL;
void addKey(int x) {
PNode t1, t2, t3;
split(root, t1, t3, x);
nodes[nodeCount].key = x;
nodes[nodeCount].prior = pri[nodeCount];
t2 = nodes + nodeCount++;
update(t2);
merge(t1, t2, root);
merge(root, t3, root);
}
void delKey(PNode &t, int x) {
if (t->key == x) {
merge(t->left, t->right, t);
} else if (x < t->key) {
delKey(t->left, x);
} else {
delKey(t->right, x);
}
update(t);
}
mt19937 mt;
int myRand(int bound) { return mt() % bound; }
char s[10];
int zzz;
int main() {
for (int i = 0; i < (int)(111111); ++i) pri[i] = i;
random_shuffle(pri, pri + 111111, myRand);
int q;
scanf("%d", &q);
for (int query = 0; query < (int)(q); ++query) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &zzz);
addKey(zzz);
} else if (s[0] == 'd') {
scanf("%d", &zzz);
delKey(root, zzz);
} else {
if (root == NULL) {
printf("0\n");
} else {
printf("%I64d\n", root->sum[2]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZ = 1 << 17;
const int MAXN = 100100;
long long tot[SIZ * 2], cou[SIZ * 2][5];
int n;
string instr[MAXN];
long long v[MAXN];
long long lis[MAXN];
int t;
map<long long, int> lookup;
void fix(int p) {
while (p != 1) {
p /= 2;
tot[p] = tot[p * 2] + tot[p * 2 + 1];
for (int i = (0); i < (5); i++) {
cou[p][i] = cou[p * 2][i];
}
int shift = tot[p * 2] % 5LL;
for (int i = (0); i < (5); i++) {
cou[p][(i + shift) % 5] += cou[p * 2 + 1][i];
}
}
}
int main() {
memset(tot, 0, sizeof(tot));
memset(cou, 0, sizeof(cou));
cin >> n;
t = 0;
for (int i = (0); i < (n); i++) {
cin >> instr[i];
if (instr[i] == "add" || instr[i] == "del") {
cin >> v[i];
lis[t++] = v[i];
}
}
sort(lis, lis + t);
int t1 = 0;
lookup.clear();
for (int i = (0); i < (t); i++) {
if (i > 0 && lis[i] != lis[i - 1]) t1++;
lookup[lis[i]] = t1;
}
for (int i = (0); i < (n); i++) {
if (instr[i] == "add") {
int p = SIZ + lookup[v[i]];
cou[p][1] = v[i];
tot[p] = 1;
fix(p);
}
if (instr[i] == "del") {
int p = SIZ + lookup[v[i]];
cou[p][1] = 0;
tot[p] = 0;
fix(p);
}
if (instr[i] == "sum") {
cout << cou[1][3] << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
inline int pt(int a[], int l, int r) {
int p, i, j;
p = a[l];
i = l;
j = r + 1;
for (;;) {
while (a[++i] < p)
if (i >= r) break;
while (a[--j] > p)
if (j <= l) break;
if (i >= j)
break;
else
swap(a[i], a[j]);
}
if (j == l) return j;
swap(a[l], a[j]);
return j;
}
inline void q_sort(int a[], int l, int r) {
int q;
if (r > l) {
q = pt(a, l, r);
q_sort(a, l, q - 1);
q_sort(a, q + 1, r);
}
}
inline void rd(int &val) {
int x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
val = x * f;
}
inline void quickSort(int s[], int l, int r) {
if (l < r) {
int i = l, j = r, x = s[l];
while (i < j) {
while (i < j && s[j] >= x) j--;
if (i < j) s[i++] = s[j];
while (i < j && s[i] < x) i++;
if (i < j) s[j--] = s[i];
}
s[i] = x;
quickSort(s, l, i - 1);
quickSort(s, i + 1, r);
}
}
int n;
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i, j, x;
string t;
cin >> n;
for (i = 0; i < n; i++) {
cin >> t;
if (t == "add") {
cin >> x;
v.insert(lower_bound(v.begin(), v.end(), x), x);
} else if (t == "del") {
cin >> x;
v.erase(lower_bound(v.begin(), v.end(), x));
} else if (t == "sum") {
long long ans = 0;
for (j = 2; j < v.size(); j += 5) ans += v[j];
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int v, size, fix;
long long sum[5];
Node *left, *right;
Node() {}
Node(int _v, Node *l = NULL, Node *r = NULL) {
v = _v, fix = rand(), left = l, right = r;
memset(sum, 0, sizeof(sum));
sum[0] = v, size = 1;
}
int lsize() { return left == NULL ? 0 : left->size; }
int rsize() { return right == NULL ? 0 : right->size; }
void Push_up() {
memset(sum, 0, sizeof(sum));
size = 0;
if (left != NULL) {
for (int i = 0; i < 5; i++) {
sum[i] = left->sum[i];
}
}
size = lsize(), sum[size % 5] += v, size++;
if (right != NULL) {
for (int i = 0; i < 5; i++) {
sum[(size + i) % 5] += right->sum[i];
}
}
size += rsize();
}
} *T = NULL;
typedef pair<Node *, Node *> pnn;
void print(Node *T, int v, int p) {
if (T == NULL) return;
for (int i = 0; i < v; i++) {
printf(" ");
}
string s = p == 0 ? "root" : p == 1 ? "left" : "right";
printf("%s:%d sum:", s.c_str(), T->v);
for (int i = 0; i < 5; i++) {
printf("%I64d ", T->sum[i]);
}
printf("\n");
print(T->left, v + 1, 1), print(T->right, v + 1, 2);
}
Node *merge(Node *l, Node *r) {
if (l == NULL || r == NULL) {
return l == NULL ? r : l;
}
if (l->fix < r->fix) {
l->right = merge(l->right, r);
l->Push_up();
return l;
}
r->left = merge(l, r->left);
r->Push_up();
return r;
}
pnn split(Node *T, int v) {
if (T == NULL) return make_pair<Node *, Node *>(NULL, NULL);
if (v > T->v) {
pnn t = split(T->right, v);
Node *l = T, *r = t.second;
l->right = t.first, l->Push_up();
return make_pair(l, r);
}
pnn t = split(T->left, v);
Node *l = t.first, *r = T;
r->left = t.second, r->Push_up();
return make_pair(l, r);
}
void add(int x) {
pnn t = split(T, x);
T = merge(t.first, merge(new Node(x), t.second));
}
void del(int x) {
pnn t1 = split(T, x);
pnn t2 = split(t1.second, x + 1);
if (t2.first != NULL) delete t2.first;
T = merge(t1.first, t2.second);
}
long long sum() { return T == NULL ? 0 : T->sum[2]; }
char buf[10];
string read() {
scanf("%s", buf);
return buf;
}
int main() {
srand((int)time(NULL));
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
string op = read();
int x;
if (op == "add") {
scanf("%d", &x);
add(x);
}
if (op == "del") {
scanf("%d", &x);
del(x);
}
if (op == "sum") {
printf("%I64d\n", sum());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node *l, *r;
int a;
const int h;
int size;
long long sum[5];
Node(int a) : l(NULL), r(NULL), a(a), h(rand()), size(0) {
for (int i = 0; i < 5; ++i) {
sum[i] = 0LL;
}
}
static int psize(Node* p) { return p == NULL ? 0 : p->size; }
static long long psum(Node* p, int i) { return p == NULL ? 0 : p->sum[i]; }
void upd() {
size = 1 + psize(l) + psize(r);
for (int i = 0; i < 5; ++i) {
sum[i] = psum(l, i);
}
sum[psize(l) % 5] += a;
for (int i = 0; i < 5; ++i) {
sum[(i + psize(l) + 1) % 5] += psum(r, i);
}
}
~Node() {
delete l;
delete r;
}
};
Node* zig(Node* p) {
Node* t = p->l;
p->l = t->r;
t->r = p;
p->upd();
t->upd();
return t;
}
Node* zag(Node* p) {
Node* t = p->r;
p->r = t->l;
t->l = p;
p->upd();
t->upd();
return t;
}
Node* insert(Node* p, int a) {
if (p == NULL) {
p = new Node(a);
} else if (a < p->a) {
p->l = insert(p->l, a);
if (p->l->h < p->h) {
p = zig(p);
}
} else {
p->r = insert(p->r, a);
if (p->r->h < p->h) {
p = zag(p);
}
}
p->upd();
return p;
}
Node* merge(Node* l, Node* r) {
if (l == NULL) {
return r;
} else if (r == NULL) {
return l;
} else if (l->h < r->h) {
l->r = merge(l->r, r);
l->upd();
return l;
} else {
r->l = merge(l, r->l);
r->upd();
return r;
}
}
Node* remove(Node* p, int a) {
if (p == NULL) {
return NULL;
} else if (a < p->a) {
p->l = remove(p->l, a);
p->upd();
} else if (a > p->a) {
p->r = remove(p->r, a);
p->upd();
} else {
Node* t = p;
p = merge(p->l, p->r);
t->l = t->r = NULL;
delete t;
}
return p;
}
int main() {
int n, a;
cin >> n;
char str[10];
Node* p = NULL;
while (n--) {
scanf("%s", str);
if (str[0] == 'a') {
scanf("%d", &a);
p = insert(p, a);
} else if (str[0] == 'd') {
scanf("%d", &a);
p = remove(p, a);
} else
printf("%I64d\n", p == NULL ? 0LL : p->sum[2]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
long long n, x, tree[N << 3][5], add[N << 2], pan[N << 2], shu[N << 2];
long long num[N << 3];
string a;
map<int, int> id;
void pushup(int k) {
num[k] = num[k * 2] + num[k * 2 + 1];
for (long long j = 0; j <= 4; ++j)
tree[k][j] =
tree[k * 2][j] + tree[k * 2 + 1][((j - num[k * 2]) % 5 + 5) % 5];
}
void update(long long l, long long r, long long k, long long wei, long long wor,
long long sum) {
if (l == r) {
tree[k][1] += wor;
num[k] += sum;
return;
}
long long mid = (l + r) >> 1;
if (wei <= mid)
update(l, mid, k * 2, wei, wor, sum);
else
update(mid + 1, r, k * 2 + 1, wei, wor, sum);
pushup(k);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
long long cnt = 0;
for (long long i = 1; i <= n; ++i) {
cin >> a;
if (a[0] == 'a') {
cin >> x;
add[++cnt] = x;
shu[i] = x;
pan[i] = 1;
} else if (a[0] == 'd') {
cin >> x;
shu[i] = x;
pan[i] = -1;
}
}
sort(add + 1, add + cnt + 1);
long long sum = 1;
for (long long i = 1; i <= cnt; ++i)
if (id[add[i]] == 0) {
id[add[i]] = sum;
++sum;
}
for (long long i = 1; i <= n; ++i)
if (pan[i] == 0)
cout << tree[1][3] << endl;
else
update(1, n, 1, id[shu[i]], pan[i] * shu[i], pan[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node_t {
int key;
node_t *ch[2];
double pri;
int cnt;
long long sum[5];
bool memed;
node_t(const int &k, double p) : key(k), pri(p), memed(false) {
ch[0] = ch[1] = 0;
cnt = 1;
for (int i = 0; i < (int)(5); i++) sum[i] = 0;
}
};
node_t *rotate(node_t *t, int b) {
node_t *s = t->ch[1 - b];
t->ch[1 - b] = s->ch[b];
s->ch[b] = t;
s->memed = t->memed = false;
return s;
}
node_t *insert(node_t *t, const int &k, double p) {
if (!t)
return new node_t(k, p);
else if (k == t->key) {
t->memed = false;
return t;
}
int b = !(k < t->key);
t->ch[b] = insert(t->ch[b], k, p);
if (t->pri > t->ch[b]->pri) t = rotate(t, 1 - b);
t->memed = false;
return t;
}
node_t *insert(node_t *t, const int &k) {
return insert(t, k, rand() / (double)RAND_MAX);
}
node_t *erase(node_t *t, const int &key) {
if (!t) {
return NULL;
}
if (key == t->key) {
if (!t->ch[0] && !t->ch[1]) return NULL;
t = rotate(t,
t->ch[0] ? t->ch[1] ? (t->ch[0]->pri < t->ch[1]->pri) : 1 : 0);
t = erase(t, key);
} else {
int b = !(key < t->key);
t->ch[b] = erase(t->ch[b], key);
}
t->memed = false;
return t;
}
inline int count(node_t *t) {
if (!t)
return 0;
else
return t->cnt;
}
void eval(node_t *t) {
if (!t) return;
if (!t->memed) {
node_t *lch = t->ch[0], *rch = t->ch[1];
eval(lch);
eval(rch);
int lcnt = count(lch);
int rcnt = count(rch);
t->cnt = lcnt + 1 + rcnt;
for (int i = 0; i < (int)(5); i++) t->sum[i] = 0;
if (lch)
for (int i = 0; i < (int)(5); i++) t->sum[i] = lch->sum[i];
t->sum[lcnt % 5] += t->key;
if (rch)
for (int i = 0; i < (int)(5); i++)
t->sum[(lcnt + 1 + i) % 5] += rch->sum[i];
t->memed = true;
}
}
pair<node_t *, node_t *> split(node_t *t, int k) {
node_t *dmy = insert(t, k, -1.0);
return make_pair(dmy->ch[0], dmy->ch[1]);
}
node_t *merge(node_t *l, node_t *r, int k) {
node_t *dmy = new node_t(k, -1.0);
dmy->ch[0] = l;
dmy->ch[1] = r;
return erase(dmy, k);
}
void print(node_t *t, int d = 0) {
if (!t) return;
print(t->ch[0], d + 1);
printf("%*s%d\n", d, "", t->key);
print(t->ch[1], d + 1);
}
int main() {
int Q;
scanf("%d", &Q);
node_t *root = NULL;
for (int q = 0; q < (int)(Q); q++) {
char buf[256];
int x;
scanf("%s", buf);
if (buf[0] == 'a') {
scanf("%d", &x);
root = insert(root, x);
} else if (buf[0] == 'd') {
scanf("%d", &x);
root = erase(root, x);
} else {
eval(root);
if (!root)
puts("0");
else
cout << root->sum[2] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> key;
int main() {
scanf("%d", &n);
char s[10];
int rep;
for (int t = 0; t < n; t++) {
scanf("%s", s);
if (s[0] == 's') {
long long ans = 0;
for (int i = 2; i < key.size(); i += 5) ans += key[i];
printf("%I64d\n", ans);
} else {
scanf("%d", &rep);
if (s[0] == 'a')
key.insert(lower_bound(key.begin(), key.end(), rep), rep);
else
key.erase(lower_bound(key.begin(), key.end(), rep));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 233;
struct cdd {
long long sum[5];
int num;
} ch[maxn * 4];
int op[maxn], a[maxn], b[maxn];
void update(int l, int r, int cur, int x) {
if (l == r) {
if (ch[cur].num == 1) {
ch[cur].num = 0;
ch[cur].sum[0] = 0;
} else {
ch[cur].num = 1;
ch[cur].sum[0] = b[l];
}
return;
}
int lc = cur << 1, rc = lc | 1, mid = (l + r >> 1);
if (x <= mid)
update(l, mid, lc, x);
else
update(mid + 1, r, rc, x);
for (int i = 0; i < 5; i++)
ch[cur].sum[i] = ch[lc].sum[i] + ch[rc].sum[(i + ch[lc].num) % 5];
ch[cur].num = ch[lc].num + ch[rc].num;
return;
}
int main() {
int n, cnt = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
if (s[0] == 'a') {
op[i] = 1;
cin >> a[i];
b[++cnt] = a[i];
} else if (s[0] == 'd') {
op[i] = 2;
cin >> a[i];
} else
op[i] = 3;
}
sort(b + 1, b + 1 + cnt);
for (int i = 1; i < 4 * maxn; i++) {
for (int j = 0; j < 5; j++) ch[i].sum[j] = 0;
ch[i].num = 0;
}
for (int i = 1; i <= n; i++) {
if (op[i] == 1) {
int k = lower_bound(b + 1, b + 1 + cnt, a[i]) - b;
update(1, cnt, 1, k);
} else if (op[i] == 2) {
int k = lower_bound(b + 1, b + 1 + cnt, a[i]) - b;
update(1, cnt, 1, k);
} else
printf("%I64d\n", ch[1].sum[3]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
long long sum[5][maxn << 2];
long long cnt[maxn << 2];
struct node {
char s[10];
int val;
} op[100010];
int b[100010];
int tot;
void push_up(int rt) {
for (int i = 0; i < 5; i++) {
sum[i][rt] =
sum[i][rt << 1] + sum[(i + 5 - cnt[rt << 1] % 5) % 5][rt << 1 | 1];
}
cnt[rt] = cnt[rt << 1] + cnt[rt << 1 | 1];
}
void update(int l, int r, int rt, int pos, int val, int key) {
if (l == r) {
sum[1][rt] += (long long)(key * (long long)val);
cnt[rt] += key;
return;
}
int m = (l + r) >> 1;
if (pos <= m)
update(l, m, rt << 1, pos, val, key);
else
update(m + 1, r, rt << 1 | 1, pos, val, key);
push_up(rt);
}
int main() {
int n;
scanf("%d", &n);
tot = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", op[i].s);
if (op[i].s[0] != 's') scanf("%d", &op[i].val);
b[tot++] = op[i].val;
}
sort(b, b + tot);
for (int i = 1; i <= n; i++) {
if (op[i].s[0] != 's') {
int pos = lower_bound(b, b + tot, op[i].val) - b;
if (op[i].s[0] == 'a')
update(0, tot, 1, pos, op[i].val, 1);
else
update(0, tot, 1, pos, op[i].val, -1);
} else
printf("%I64d\n", sum[3][1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:16000000")
#pragma warning(disable : 4996)
const int inf = 1 << 25;
const double eps = 1e-9;
struct Bucket {
const static int SIZE = 512;
int elems[SIZE];
long long ps[5];
int size;
Bucket() {
memset((elems), (0), sizeof(elems));
memset((ps), (0), sizeof(ps));
size = 0, offset = 0;
}
int offset;
void shft(int x) {
offset += x;
if (offset < 0) offset = 4;
if (offset > 4) offset = 0;
}
void add(int id, int x) {
elems[id] = x;
recalc();
}
void del(int id) {
elems[id] = 0;
recalc();
}
int Size() const { return size; }
void recalc() {
size = 0;
memset((ps), (0), sizeof(ps));
for (int i = 0, j = 0; i < SIZE; ++i)
if (elems[i]) {
++size;
ps[j % 5] += elems[i];
++j;
}
}
long long Sum() const {
for (int x = 0;; ++x)
if ((offset + x) % 5 == 2) return ps[x];
}
};
vector<Bucket> buckets;
long long sum() {
long long ret = 0;
for (int i = (0); i < ((int)buckets.size()); ++i) ret += buckets[i].Sum();
return ret;
}
vector<int> elems;
vector<pair<string, int> > queries;
int main() {
int q;
cin >> q;
for (int i = (0); i < (q); ++i) {
string cmd;
cin >> cmd;
if (cmd == "sum")
queries.push_back(make_pair("sum", 0));
else {
int x;
cin >> x;
queries.push_back(make_pair(cmd, x));
elems.push_back(x);
}
}
sort(elems.begin(), elems.end());
elems.resize(unique(elems.begin(), elems.end()) - elems.begin());
buckets.resize(elems.size() / Bucket::SIZE + 2);
for (int i = (0); i < (q); ++i) {
string cmd = queries[i].first;
int x = queries[i].second;
if (cmd == "sum")
cout << sum() << endl;
else {
int id = lower_bound(elems.begin(), elems.end(), x) - elems.begin();
int bid = id / Bucket::SIZE;
if (cmd == "add") {
buckets[bid].add(id % Bucket::SIZE, x);
for (int i = (bid + 1); i < ((int)buckets.size()); ++i)
buckets[i].shft(1);
} else {
buckets[bid].del(id % Bucket::SIZE);
for (int i = (bid + 1); i < ((int)buckets.size()); ++i)
buckets[i].shft(-1);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ts[200];
int s[800010];
int tot, b[800010], n, a1, A[800010], B[800010];
long long tr[2100000][6];
void update(int a) {
s[a] = s[a * 2] + s[a * 2 + 1];
for (int i = 0; i < 5; i++)
tr[a][i] = tr[a * 2][i] + tr[a * 2 + 1][(i - s[a * 2] % 5 + 5) % 5];
}
void ins(int l, int r, int p, int q, int now, int ke) {
if (p <= l && r <= q) {
tr[now][0] = ke;
if (ke == 0)
s[now] = 0;
else
s[now] = 1;
} else {
int mi = (l + r) / 2;
if (p < mi) ins(l, mi, p, q, now * 2, ke);
if (mi < q) ins(mi, r, p, q, now * 2 + 1, ke);
update(now);
}
}
int main() {
scanf("%d", &n);
tot = 0;
for (int i = 0; i < n; i++) {
scanf(" %s", &ts);
if (ts[0] == 'a') {
scanf("%d", &a1);
A[i] = 0, B[i] = a1;
b[tot++] = a1;
} else if (ts[0] == 'd') {
scanf("%d", &a1);
A[i] = 1, B[i] = a1;
b[tot++] = a1;
} else
A[i] = 2;
}
sort(b, b + tot);
tot = unique(b, b + tot) - b;
for (int i = 0; i < n; i++) {
if (A[i] == 0) {
int a = lower_bound(b, b + tot, B[i]) - b;
a++;
while (b[a - 1] != B[i]) cout << b[a - 1] << ' ' << B[i] << endl;
ins(0, tot, a - 1, a, 1, B[i]);
} else if (A[i] == 1) {
int a = lower_bound(b, b + tot, B[i]) - b;
a++;
while (b[a - 1] != B[i]) cout << i << endl;
ins(0, tot, a - 1, a, 1, 0);
} else
printf("%I64d\n", tr[1][2]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int left, right;
int cnt;
long long sum[5];
} L[100005 * 4];
int n, tot, a[100005], k, q[100005];
char str[100005][10];
void Bulid(int step, int l, int r) {
L[step].left = l;
L[step].right = r;
L[step].cnt = 0;
memset(L[step].sum, 0, sizeof(L[step].sum));
if (l == r) return;
int m = (l + r) / 2;
Bulid((step << 1), l, m);
Bulid((step << 1 | 1), m + 1, r);
}
void Push_Up(int step) {
for (int i = 0; i < 5; i++)
L[step].sum[i] =
(long long)L[(step << 1)].sum[i] +
L[(step << 1 | 1)].sum[((i - L[(step << 1)].cnt) % 5 + 5) % 5];
}
void Update(int step, int pos, int num) {
L[step].cnt += 2 * k - 1;
if (L[step].left == L[step].right) {
L[step].sum[0] = (long long)k * num;
return;
}
int m = (L[step].left + L[step].right) / 2;
if (pos <= m)
Update((step << 1), pos, num);
else
Update((step << 1 | 1), pos, num);
Push_Up(step);
}
int main() {
while (scanf("%d", &n) != EOF) {
tot = 0;
for (int i = 0; i < n; i++) {
scanf("%s", str[i]);
if (str[i][0] != 's') {
scanf("%d", &q[i]);
a[tot++] = q[i];
}
}
sort(a, a + tot);
tot = unique(a, a + tot) - a;
if (tot == 0)
memset(L[1].sum, 0, sizeof(L[1].sum));
else
Bulid(1, 1, tot);
for (int i = 0; i < n; i++) {
int pos = lower_bound(a, a + tot, q[i]) - a;
if (str[i][0] == 'a')
k = 1, Update(1, pos, q[i]);
else if (str[i][0] == 'd')
k = 0, Update(1, pos, q[i]);
else
printf("%I64d\n", L[1].sum[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int cn;
long long sm[5];
} tr[(100000 << 3) + 100];
void update(int p, int v, int m, int op, int st, int fn) {
if (st == fn) {
if (op == 1) {
tr[p].sm[0] += v;
tr[p].cn++;
} else {
tr[p].sm[0] -= v;
tr[p].cn--;
}
return;
}
int md = (st + fn) >> 1, lf = (p << 1) + 1, rt = lf + 1;
if (m <= md)
update(lf, v, m, op, st, md);
else
update(rt, v, m, op, md + 1, fn);
md = tr[lf].cn % 5;
int i;
for (i = 0; i < 5; i++) tr[p].sm[i] = tr[lf].sm[i] + tr[rt].sm[(i + md) % 5];
tr[p].cn = tr[p].cn + op;
}
pair<string, int> qr[100000 + 10];
map<int, int> M;
int main() {
char wd[10];
int n, i, u, L;
cin >> n;
for (i = 0; i < n; i++) {
scanf("%s", wd);
if (wd[0] != 's') {
scanf("%d", &u);
M[u] = 0;
qr[i] = make_pair(string(wd), u);
} else
qr[i] = make_pair(string(wd), 0);
}
i = 1;
for (map<int, int>::iterator it = M.begin(); it != M.end(); it++) {
it->second = i++;
}
L = i;
for (i = 0; i < n; i++) {
if (qr[i].first[0] == 's') {
printf("%I64d\n", tr[0].sm[3]);
} else {
update(0, qr[i].second, M[qr[i].second], qr[i].first[0] == 'a' ? 1 : -1,
1, n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tmp, cnt, b[200012];
struct data {
long long type, x, id;
} a[200012];
struct node {
long long l, r, w[5], cnt;
};
struct segtree {
node tr[200012 * 8];
void up(long long rt) {
long long i;
tr[rt].cnt = tr[rt << 1].cnt + tr[rt << 1 | 1].cnt;
for (i = 0; i <= 4; ++i)
tr[rt].w[i] = tr[rt << 1].w[i] +
tr[rt << 1 | 1].w[((i - tr[rt << 1].cnt) % 5 + 5) % 5];
}
void mk(long long rt) {
long long l = tr[rt].l, r = tr[rt].r, mid = (tr[rt].l + tr[rt].r) >> 1;
if (l == r) return;
tr[rt << 1].l = l;
tr[rt << 1].r = mid;
mk(rt << 1);
tr[rt << 1 | 1].l = mid + 1;
tr[rt << 1 | 1].r = r;
mk(rt << 1 | 1);
}
void add(long long a, long long b, long long num, long long rt) {
long long l = tr[rt].l, r = tr[rt].r, mid = (tr[rt].l + tr[rt].r) >> 1;
if (l == r) {
tr[rt].w[1] += num * b;
tr[rt].cnt += b;
return;
}
if (a <= mid)
add(a, b, num, rt << 1);
else
add(a, b, num, rt << 1 | 1);
up(rt);
}
} tree;
map<long long, long long> mp;
signed main() {
long long i, m, x;
char str[8];
scanf("%lld\n", &m);
for (i = 1; i <= m; ++i) {
scanf("%s ", str);
if (str[0] == 'a') {
scanf("%lld\n", &x);
a[i].type = 1;
a[i].x = x;
b[++cnt] = x;
} else if (str[0] == 'd') {
scanf("%lld\n", &x);
a[i].type = 2;
a[i].x = x;
} else
a[i].type = 0;
}
sort(b + 1, b + cnt + 1);
for (i = 1; i <= cnt; ++i)
if (b[i] != b[i - 1]) mp[b[i]] = ++tmp;
for (i = 1; i <= m; ++i)
if (a[i].x) a[i].id = mp[a[i].x];
if (cnt == 0) {
for (i = 1; i <= m; ++i) printf("0\n");
return 0;
}
tree.tr[1].l = 1;
tree.tr[1].r = cnt;
tree.mk(1);
for (i = 1; i <= m; ++i) {
if (a[i].type == 1)
tree.add(a[i].id, 1, a[i].x, 1);
else if (a[i].type == 2)
tree.add(a[i].id, -1, a[i].x, 1);
else
printf("%lld\n", tree.tr[1].w[3]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const long long linf = 2e18;
const int MOD = 1000000007;
const double eps = 1e-7;
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T>
void print(T a) {
cout << a << endl;
exit(0);
}
template <class T>
void chmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
void chmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void upd(T &a, T b) {
(a += b) %= MOD;
}
template <class T>
void mul(T &a, T b) {
a = (long long)a * b % MOD;
}
long long n, x;
long long tree[800005][6], add[400005], pan[400005], shu[400005];
long long num[800005];
char a[10];
map<long long, long long> id;
inline long long read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long ls(long long k) { return k << 1; }
long long rs(long long k) { return k << 1 | 1; }
void push_up(long long i) {
num[i] = num[ls(i)] + num[rs(i)];
for (long long j = 0; j <= 4; j++) {
tree[i][j] = tree[ls(i)][j] + tree[rs(i)][((j - num[ls(i)]) % 5 + 5) % 5];
}
}
inline void in(long long left, long long right, long long i, long long wei,
long long wor, long long sum) {
if (left == right) {
tree[i][1] += wor;
num[i] += sum;
return;
} else {
long long mid = (left + right) / 2;
if (wei <= mid)
in(left, mid, ls(i), wei, wor, sum);
else
in(mid + 1, right, rs(i), wei, wor, sum);
push_up(i);
}
}
int main() {
long long cnt = 0;
n = read();
for (long long i = 1; i <= n; i++) {
cin >> a;
if (a[0] == 'a') {
x = read();
add[++cnt] = x;
shu[i] = x;
pan[i] = 1;
}
if (a[0] == 'd') {
x = read();
shu[i] = x;
pan[i] = -1;
}
}
sort(add + 1, add + cnt + 1);
long long sum = 1;
for (long long i = 1; i <= cnt; i++) {
if (id[add[i]] == 0) {
id[add[i]] = sum;
sum++;
}
}
for (long long i = 1; i <= n; i++) {
if (pan[i] == 0)
printf("%lld\n", tree[1][3]);
else {
in(1, n, 1, id[shu[i]], pan[i] * shu[i], pan[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
char s[10];
int main() {
int n;
cin >> n;
while (n--) {
scanf("%s", s);
int x;
if (s[0] == 'a' || s[0] == 'd') scanf("%d", &x);
if (s[0] == 'a')
v.insert(lower_bound(v.begin(), v.end(), x), x);
else if (s[0] == 'd')
v.erase(lower_bound(v.begin(), v.end(), x));
else {
int i = 2;
long long int sum = 0;
while (i < v.size()) {
sum += v[i];
i += 5;
}
printf("%lld\n", sum);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> a;
a.reserve(n);
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s == "sum") {
long long sum = 0;
int sz = a.size();
for (int j = 2; j < sz; j += 5) sum += a[j];
printf("%I64d\n", sum);
} else {
int x;
scanf("%d", &x);
if (s == "add") {
a.insert(lower_bound(a.begin(), a.end(), x), x);
} else {
a.erase(lower_bound(a.begin(), a.end(), x));
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct S {
char op[5];
int x, id;
} e[100005];
bool cmpval(S a, S b) {
if (a.x == b.x) return a.op[0] < b.op[0];
return a.x < b.x;
}
bool cmpid(S a, S b) { return a.id < b.id; }
int n, cnt, val[100005], num[400005];
long long sum[400005][5];
void build(int idx, int s, int e) {
if (s != e) {
int mid = (s + e) >> 1;
build(idx << 1, s, mid);
build(idx << 1 | 1, mid + 1, e);
}
num[idx] = 0;
for (int i = 0; i < 5; i++) sum[idx][i] = 0;
}
void update(int idx, int s, int e, int pos, int flag) {
num[idx] += flag;
if (s == e) {
sum[idx][1] += (long long)val[s] * flag;
return;
}
int mid = (s + e) >> 1;
if (pos <= mid)
update(idx << 1, s, mid, pos, flag);
else
update(idx << 1 | 1, mid + 1, e, pos, flag);
for (int i = 0; i < 5; i++)
sum[idx][i] =
sum[idx << 1][i] + sum[idx << 1 | 1][i - num[idx << 1] % 5 >= 0
? i - num[idx << 1] % 5
: i - num[idx << 1] % 5 + 5];
}
long long query(int idx, int s, int e, int mod) {
return sum[idx << 1][mod] +
sum[idx << 1 | 1]
[mod - num[idx << 1] % 5 >= 0 ? mod - num[idx << 1] % 5
: mod - num[idx << 1] % 5 + 5];
}
int main() {
int i, j;
long long ans;
while (~scanf("%d", &n)) {
map<int, int> mp;
for (i = 0; i < n; i++) {
scanf("%s", e[i].op);
if (e[i].op[0] == 's')
e[i].x = 0;
else
scanf("%d", &e[i].x);
e[i].id = i;
}
sort(e, e + n, cmpval);
cnt = 1;
for (i = 0; i < n; i++) {
if (e[i].op[0] == 'a') {
if (!mp[e[i].x]) mp[e[i].x] = cnt++;
val[mp[e[i].x]] = e[i].x;
e[i].x = mp[e[i].x];
} else if (e[i].op[0] == 'd') {
e[i].x = mp[e[i].x];
}
}
sort(e, e + n, cmpid);
cnt--;
if (!cnt) {
for (i = 0; i < n; i++) {
if (e[i].op[0] == 's') {
printf("0\n");
}
}
continue;
}
build(1, 1, cnt);
for (i = 0; i < n; i++) {
if (e[i].op[0] == 'a')
update(1, 1, cnt, e[i].x, 1);
else if (e[i].op[0] == 'd')
update(1, 1, cnt, e[i].x, -1);
else
printf("%I64d\n", query(1, 1, n, 3));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10;
long long a[maxn];
struct treap {
treap *lc, *rc;
long long val, pri, sum, sz;
treap(long long v) : val(v) {
lc = rc = nullptr;
sz = 1;
pri = rand();
sum = v;
}
void pull() {
sz = (lc ? lc->sz : 0) + (rc ? rc->sz : 0) + 1;
sum = val + (lc ? lc->sum : 0) + (rc ? rc->sum : 0);
}
} * tr[5], *another;
treap *merge(treap *a, treap *b) {
if (!a || !b) return a ? a : b;
if (a->pri > b->pri) {
a->rc = merge(a->rc, b);
a->pull();
return a;
} else {
b->lc = merge(a, b->lc);
b->pull();
return b;
}
}
void split(treap *t, long long k, treap *&a, treap *&b) {
if (!t) return (a = nullptr, b = nullptr), void();
if (t->val <= k) {
a = t;
split(t->rc, k, a->rc, b);
a->pull();
} else {
b = t;
split(t->lc, k, a, b->lc);
b->pull();
}
}
long long get_pos(long long v) {
treap *a, *b;
split(another, v - 1, a, b);
long long ret = (a ? a->sz : 0) + 1;
another = merge(a, b);
return ret;
}
vector<treap *> get_suff(long long v) {
vector<treap *> ret;
for (long long i = 0; i < 5; ++i) {
treap *a, *b;
split(tr[i], v, a, b);
ret.push_back(b);
tr[i] = a;
}
return ret;
}
void insert(treap *&t, long long v) {
treap *a, *b;
split(t, v - 1, a, b);
t = merge(merge(a, new treap(v)), b);
}
void erase(treap *&t, long long v) {
treap *a, *b, *c, *d;
split(t, v - 1, a, b);
split(b, v, c, d);
t = merge(a, d);
}
int32_t main() {
srand(7122);
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
while (n--) {
string s;
cin >> s;
if (s == "add") {
long long x;
cin >> x;
long long k = get_pos(x);
vector<treap *> suff = get_suff(x);
for (long long i = 0; i < 5; ++i) {
long long j = (i + 1) % 5;
tr[j] = merge(tr[j], suff[i]);
}
insert(tr[k % 5], x);
insert(another, x);
}
if (s == "del") {
long long x;
cin >> x;
long long k = get_pos(x);
vector<treap *> suff = get_suff(x);
for (long long i = 0; i < 5; ++i) {
long long j = (i - 1 + 5) % 5;
tr[j] = merge(tr[j], suff[i]);
}
erase(tr[k % 5], x);
erase(another, x);
}
if (s == "sum") {
cout << (tr[3] ? tr[3]->sum : 0) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
int cnt[262200];
long long sum[262200][5];
void chan(int x) {
int i, l = x << 1, r = (x << 1) + 1;
cnt[x] = cnt[l] + cnt[r];
for (int(i) = (0); (i) <= (4); (i)++)
sum[x][i] = sum[l][i] + sum[r][(i - cnt[l] % 5 + 5) % 5];
}
int n, a[100005];
vector<pair<int, int> > v;
vector<int> num;
int main() {
cin >> n;
for (int(i) = (1); (i) <= (n); (i)++) {
string com;
int g;
cin >> com;
if (com[0] != 's') {
cin >> g;
}
v.push_back(make_pair(com[0] == 's' ? inf : g, com[0]));
if (com[0] != 's') num.push_back(g);
}
sort(num.begin(), num.end());
int s = unique(num.begin(), num.end()) - num.begin();
for (int(i) = (1); (i) <= (n); (i)++) {
pair<int, int> now = v[i - 1];
if (now.second == 's')
cout << sum[1][2] << endl;
else {
int typ = now.second == 'a' ? 0 : 1,
id = (1 << 17) +
(lower_bound(num.begin(), num.begin() + s, now.first) -
num.begin());
cnt[id] = 1 - typ;
sum[id][0] = (1 - typ) * now.first;
for (int j = id >> 1; j; j >>= 1) chan(j);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class IO {
static const int bufSize = 1 << 18;
char inBuf[bufSize], outBuf[bufSize];
char *ip1 = inBuf, *ip2 = inBuf;
int goodReadBit = 0, op1 = -1, op2 = bufSize - 1;
template <typename T>
__inline__ __attribute__((always_inline)) void __RI(T& x) {
int ch = gc(), neg = 1;
x = 0;
for (; !(isdigit(ch) || ch == '-' || ch == EOF); ch = gc())
;
if (ch == EOF) {
goodReadBit = 0;
return;
}
if (ch == '-') neg = -1, ch = gc();
for (; isdigit(ch); ch = gc()) x = x * 10 + (ch - 48) * neg;
}
template <typename T>
__inline__ __attribute__((always_inline)) void __RC(T& x) {
unsigned char ch;
while (isspace(ch = gc()))
;
x = ch;
}
__inline__ __attribute__((always_inline)) void __RS(string& x) {
char ch;
x.clear();
for (ch = gc(); isspace(ch); ch = gc())
;
if (ch == EOF) {
goodReadBit = 0;
return;
}
for (; !isspace(ch); ch = gc()) x.push_back(ch);
}
public:
__inline__ __attribute__((always_inline)) int gc() {
return ip1 == ip2 && (ip2 = (ip1 = inBuf) + fread(inBuf, 1, bufSize, stdin),
ip1 == ip2)
? EOF
: *ip1++;
}
__inline__ __attribute__((always_inline)) IO& R(char& x) {
__RC(x);
return (*this);
}
__inline__ __attribute__((always_inline)) IO& R(unsigned char& x) {
__RC(x);
return (*this);
}
__inline__ __attribute__((always_inline)) IO& R(string& x) {
__RS(x);
return (*this);
}
template <typename T1, typename T2>
__inline__ __attribute__((always_inline)) IO& R(pair<T1, T2>& x) {
R(x.first), R(x.second);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& R(vector<T>& x) {
for (auto& i : x) R(i);
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& RA(T* a, int n) {
for (int i = 0; i < n; ++i) R(a[i]);
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& R(T& x, Args&... args) {
R(x), R(args...);
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& RA(T* a, int n, Args... args) {
for (int i = 0; i < n; ++i) RA(a[i], args...);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& R(T& x) {
static_assert(is_integral<T>::value, "Unsupported types");
if (is_integral<T>::value) __RI(x);
return (*this);
}
private:
char space = ' ';
template <typename T>
__inline__ __attribute__((always_inline)) void __WI(T x) {
static char buf[64];
static int len = -1;
if (x >= 0) {
do {
buf[++len] = x % 10 + 48, x /= 10;
} while (x);
} else {
pc('-');
do {
buf[++len] = -(x % 10) + 48, x /= 10;
} while (x);
}
while (len >= 0) {
pc(buf[len]), --len;
}
}
public:
__inline__ __attribute__((always_inline)) void pc(const char& x) {
if (op1 == op2) flush();
outBuf[++op1] = x;
}
__inline__ __attribute__((always_inline)) void flush() {
fwrite(outBuf, 1, op1 + 1, stdout), op1 = -1;
}
__inline__ __attribute__((always_inline)) IO& W(const char& x) {
pc(x);
return (*this);
}
__inline__ __attribute__((always_inline)) IO& W(const char* x) {
while (*x != '\0') pc(*(x++));
return (*this);
}
__inline__ __attribute__((always_inline)) IO& W(const string& x) {
W(x.c_str());
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& W(const vector<T>& x) {
for (auto& i : x) WS(i);
WL();
return (*this);
}
__inline__ __attribute__((always_inline)) IO& WL() {
W('\n');
return (*this);
}
template <typename T1, typename T2>
__inline__ __attribute__((always_inline)) IO& W(pair<T1, T2>& x) {
WS(x.first), W(x.second);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& WL(const T& x) {
W(x), W('\n');
return (*this);
}
__inline__ __attribute__((always_inline)) IO& WS() {
W(' ');
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& WS(const T& x) {
W(x), W(space);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& WA(T* a, int n) {
for (int i = 0; i < n; i++) WS(a[i]);
WL();
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& W(const T& x,
const Args&... args) {
W(x), W(space), W(args...);
return (*this);
}
template <typename... Args>
__inline__ __attribute__((always_inline)) IO& WL(const Args&... args) {
W(args...), W('\n');
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& WA(T* a, int n, Args... args) {
for (int i = 0; i < n; i++) WA(a[i], args...);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& W(const T& x) {
static_assert(is_integral<T>::value, "Unsupported types");
if (is_integral<T>::value) __WI(x);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& operator>>(T& x) {
R(x);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& operator<<(const T& x) {
W(x);
return (*this);
}
IO() {}
} io;
void EXIT(int code) { io.flush(), exit(code); }
const int8_t INFC = 0x3f;
const int16_t INFS = 0x3f3f;
const int32_t INF = 0x3f3f3f3f;
const int64_t INFL = 0x3f3f3f3f3f3f3f3fLL;
vector<pair<string, int> > ops;
map<int, int> fmap, rmap;
struct SegmentTree {
struct Node {
int64_t sum[5];
int cnt = 0;
};
static const int MAXN = 1 << 20;
Node data[MAXN];
int N;
void init(int n) {
N = 1;
while (N < n) N <<= 1;
}
void add(int x) {
int k = x + N - 1;
data[k].cnt = 1;
data[k].sum[0] = rmap[x];
while (k) {
k = (k - 1) >> 1;
data[k].cnt = data[(k << 1) + 1].cnt + data[(k << 1) + 2].cnt;
for (int i = 0; i < 5; i++)
data[k].sum[i] =
data[(k << 1) + 1].sum[i] +
data[(k << 1) + 2].sum[(i - data[(k << 1) + 1].cnt % 5 + 5) % 5];
}
}
void del(int x) {
int k = x + N - 1;
data[k].cnt = 0;
data[k].sum[0] = 0;
while (k) {
k = (k - 1) / 2;
data[k].cnt = data[(k << 1) + 1].cnt + data[(k << 1) + 2].cnt;
for (int i = 0; i < 5; i++)
data[k].sum[i] =
data[(k << 1) + 1].sum[i] +
data[(k << 1) + 2].sum[(i - data[(k << 1) + 1].cnt % 5 + 5) % 5];
}
}
} segmentTree;
int main() {
int q;
io >> q;
ops.resize(q);
for (auto& [k, v] : ops) {
io >> k;
if (k[0] != 's') io >> v, fmap[v] = 1;
}
segmentTree.init(fmap.size());
int key = 0;
for (auto& [k, v] : fmap) key++, v = key, rmap[key] = k;
for (auto& [k, v] : ops)
if (k[0] != 's') v = fmap[v];
for (auto [k, v] : ops) {
if (k[0] == 's')
io.WL(segmentTree.data[0].sum[2]);
else if (k[0] == 'a')
segmentTree.add(v);
else if (k[0] == 'd')
segmentTree.del(v);
}
EXIT(0);
}
|
#include <bits/stdc++.h>
using namespace std;
long long h[100010], dat[100010], s[100010][5];
int n, root, tot, l[100010], r[100010], sum[100010];
inline void update(int x) {
if (!x) return;
int ss = sum[l[x]] + 1;
for (int i = 0; i < 5; i++)
s[x][i] = (long long)(s[l[x]][i] + s[r[x]][(i - ss % 5 + 5) % 5]);
s[x][ss % 5] += (long long)dat[x];
sum[x] = ss + sum[r[x]];
h[x] = max(h[l[x]], h[r[x]]) + 1;
}
inline void zig(int &x) {
int y = l[x];
l[x] = r[y];
r[y] = x;
update(x);
update(y);
x = y;
}
inline void zag(int &x) {
int y = r[x];
r[x] = l[y];
l[y] = x;
update(x);
update(y);
x = y;
}
inline void balance(int &x) {
update(x);
if (h[l[x]] > h[r[x]] + 1) {
if (h[l[l[x]]] < h[l[r[x]]]) zag(l[x]);
zig(x);
}
if (h[r[x]] > h[l[x]] + 1) {
if (h[r[r[x]]] < h[r[l[x]]]) zig(r[x]);
zag(x);
}
}
inline void ins(int &x, long long v) {
if (!x) {
dat[x = ++tot] = v;
l[x] = r[x] = 0;
} else
ins(v < dat[x] ? l[x] : r[x], v);
balance(x);
}
inline void del(int &x, long long v) {
if ((!l[x]) && (!r[x])) {
dat[x] = 0;
x = 0;
return;
}
if (dat[x] == v) {
if (h[l[x]] > h[r[x]]) {
zig(x);
del(r[x], v);
} else {
zag(x);
del(l[x], v);
}
} else
del(v < dat[x] ? l[x] : r[x], v);
balance(x);
}
int main() {
scanf("%d\n", &n);
memset(l, 0, sizeof(l));
memset(r, 0, sizeof(r));
memset(s, 0, sizeof(s));
memset(h, 0, sizeof(h));
memset(dat, 0, sizeof(dat));
memset(sum, 0, sizeof(sum));
root = 1;
tot = 0;
h[0] = -1;
while (n--) {
char x[10];
scanf("%s", &x);
char y = x[0];
long long z;
if (y == 'a') {
scanf("%I64d", &z);
ins(root, z);
} else if (y == 'd') {
scanf("%I64d", &z);
del(root, z);
} else
printf("%I64d\n", s[root][3]);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.