text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int n, m, k;
set<set<int> > ha[maxn][maxn];
string mat[maxn];
int stran[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
int br, bc;
int er, ec;
int dis(int r1, int c1, int r2, int c2) { return abs(r1 - r2) + abs(c1 - c2); }
struct node {
int r, c;
string s;
int bu;
int cu;
string used;
friend bool operator<(const node &a, const node &b) {
if (a.bu + dis(a.r, a.c, er, ec) == b.bu + dis(b.r, b.c, er, ec)) {
return a.s > b.s;
}
return a.bu + dis(a.r, a.c, er, ec) > b.bu + dis(b.r, b.c, er, ec);
}
};
priority_queue<node> que;
set<int> uu;
int main() {
cin >> n >> m >> k;
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') {
br = i;
bc = j;
}
if (mat[i][j] == 'T') {
er = i;
ec = j;
}
}
}
node now, ne;
now.bu = 0;
now.s.clear();
now.r = br;
now.c = bc;
now.cu = 0;
now.used.clear();
que.push(now);
while (!que.empty()) {
now = que.top();
que.pop();
if (mat[now.r][now.c] == 'T') {
cout << now.s << endl;
return 0;
}
string ss = now.used, ness;
string ro = now.s;
int nr = now.r, nc = now.c;
uu.clear();
for (int i = 0; i < ss.length(); i++) {
uu.insert(ss[i] - 'a');
}
if (ha[nr][nc].find(uu) != ha[nr][nc].end()) continue;
ha[nr][nc].insert(uu);
int ner, nec;
for (int i = 0; i < 4; i++) {
ner = nr + stran[i][0];
nec = nc + stran[i][1];
if (ner >= 0 && ner < n && nec >= 0 && nec < m) {
char p = mat[ner][nec];
ne.r = ner;
ne.c = nec;
ne.bu = now.bu + 1;
if (p != 'T' && p != 'S') {
bool hu = 0;
for (int j = 0; j < ss.length(); j++) {
if (p == ss[j]) {
hu = 1;
break;
}
}
if (hu == 1) {
ne.used = ss;
ne.cu = now.cu;
ne.s = now.s + p;
que.push(ne);
} else {
if (now.cu + 1 <= k) {
ne.used = ss + p;
ne.cu = now.cu + 1;
ne.s = now.s + p;
que.push(ne);
}
}
} else if (p == 'T') {
ne = now;
ne.bu++;
ne.r = er;
ne.c = ec;
que.push(ne);
}
}
}
}
cout << "-1" << endl;
return 0;
}
|
#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;
int n, m, k, sx, sy, ex, ey;
bool valid[127];
char s[55][55];
int q[55 * 55 * 2], op, cl;
int dis[55][55];
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
bool good[55][55];
string out;
void bfs2() {
string res = "";
memset(good, false, sizeof(good));
op = cl = 0;
q[op++] = ex;
q[op++] = ey;
good[ex][ey] = true;
char bes = 'S', prev = 'z';
int d = dis[ex][ey];
while (op != cl) {
int x = q[cl++], y = q[cl++];
if (dis[x][y] != d) {
--d;
if (bes != 'S') res += bes;
bes = prev;
prev = 'z';
}
if (x == sx && y == sy) break;
if (s[x][y] != bes) continue;
for (int i = 0; i < 4; i++) {
int xx = x - dx[i], yy = y - dy[i];
if (xx >= 0 && xx < n && yy >= 0 && yy < m &&
dis[xx][yy] == dis[x][y] - 1 && !good[xx][yy]) {
good[xx][yy] = true;
q[op++] = xx;
q[op++] = yy;
if (s[xx][yy] < prev) prev = s[xx][yy];
}
}
}
if (out == "-1" || out.length() > res.length() ||
out.length() == res.length() && out > res)
out = res;
}
void bfs() {
op = cl = 0;
q[op++] = sx;
q[op++] = sy;
memset(dis, -1, sizeof(dis));
dis[sx][sy] = 0;
while (op != cl) {
int x = q[cl++], y = q[cl++];
if (x == ex && y == ey) {
bfs2();
return;
}
for (int i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (xx >= 0 && xx < n && yy >= 0 && yy < m) {
if (valid[s[xx][yy]] && dis[xx][yy] == -1) {
q[op++] = xx;
q[op++] = yy;
dis[xx][yy] = dis[x][y] + 1;
}
}
}
}
}
void dfs(int i, char s) {
if (i == k) {
bfs();
return;
}
while (s <= 'z') {
valid[s] = true;
dfs(i + 1, s + 1);
valid[s] = false;
++s;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
for (int j = 0; j < m; j++)
if (s[i][j] == 'T') {
sx = i;
sy = j;
} else if (s[i][j] == 'S') {
ex = i;
ey = j;
}
}
valid['S'] = true;
out = "-1";
dfs(0, 'a');
puts(out.c_str());
return 0;
}
|
#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;
int g[60][60];
char ss[110];
int sx, sy;
int gx, gy;
int res[60];
int lim;
bool can[300];
bool have;
int cc;
int vis[60][60];
int n, m;
int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1};
int dis[60][60];
string pre[60][60];
struct point {
int x, y;
};
char chs[10];
bool cmp(const int &cmp1, const int &cmp2) { return chs[cmp1] < chs[cmp2]; }
int bfs() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
vis[i][j] = 0;
}
}
point p0 = {sx, sy};
queue<point> q;
q.push(p0);
vis[sx][sy] = 1;
dis[sx][sy] = 0;
pre[sx][sy][0] = -1;
while (!q.empty()) {
point p = q.front();
q.pop();
if (p.x == gx && p.y == gy) {
return dis[gx][gy];
}
for (int d = 0; d < 4; d++) {
point np = {p.x + dir[d][0], p.y + dir[d][1]};
if (g[np.x][np.y] != -1 && (can[g[np.x][np.y]] || g[np.x][np.y] == 'T')) {
if (vis[np.x][np.y]) {
if (dis[np.x][np.y] == dis[p.x][p.y] + 1) {
if (pre[np.x][np.y] > pre[p.x][p.y] + (char)g[np.x][np.y]) {
pre[np.x][np.y] = pre[p.x][p.y] + (char)g[np.x][np.y];
}
}
} else {
vis[np.x][np.y] = 1;
dis[np.x][np.y] = dis[p.x][p.y] + 1;
pre[np.x][np.y] = pre[p.x][p.y] + (char)g[np.x][np.y];
q.push(np);
}
}
}
}
return -1;
}
int minv;
char ans[5100];
char tmp2[5100];
int ansxx;
void dfs(int cur) {
if (cur == lim) {
have = true;
int ret = bfs();
if (ret != -1) {
if (minv > ret) {
minv = ret;
strcpy(ans, pre[gx][gy].c_str());
} else if (minv == ret) {
if (strcmp(ans, pre[gx][gy].c_str()) > 0) {
strcpy(ans, pre[gx][gy].c_str());
}
}
}
} else {
int base = (cur == 0) ? 0 : (res[cur - 1] + 1);
for (int i = base; i < cc; i++) {
res[cur] = i;
can[ss[i]] = true;
dfs(cur + 1);
can[ss[i]] = false;
}
}
}
int main() {
char str[110];
int tvis[300];
scanf("%d%d%d", &n, &m, &lim);
cc = 0;
memset(tvis, 0, sizeof(tvis));
for (int i = 1; i <= n; i++) {
scanf("%s", str);
for (int j = 1; j <= m; j++) {
g[i][j] = str[j - 1];
if (g[i][j] == 'S') {
sx = i;
sy = j;
} else if (g[i][j] == 'T') {
gx = i;
gy = j;
} else {
if (!tvis[g[i][j]]) {
tvis[g[i][j]] = 1;
ss[cc++] = g[i][j];
}
}
}
}
for (int i = 0; i <= n + 1; i++) {
g[i][0] = g[i][m + 1] = -1;
}
for (int i = 0; i <= m + 1; i++) {
g[0][i] = g[n + 1][i] = -1;
}
sort(ss, ss + cc);
memset(can, 0, sizeof(can));
have = false;
minv = 1 << 30;
dfs(0);
if (!have) {
for (int i = 0; i < cc; i++) {
can[ss[i]] = true;
}
int ret = bfs();
if (ret != -1) {
if (minv > ret) {
minv = ret;
strcpy(ans, pre[gx][gy].c_str());
} else if (minv == ret) {
if (strcmp(ans, pre[gx][gy].c_str()) > 0) {
strcpy(ans, pre[gx][gy].c_str());
}
}
}
}
if (minv == 1 << 30) {
printf("%d\n", -1);
} else {
ans[minv - 1] = '\0';
printf("%s\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T &first) {
return first * first;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-9;
char TEMPORARY_CHAR;
const int INF = 1e9;
inline void fft(vector<complex<long double> > &a, bool invert) {
int n = (int)a.size();
for (int i = 1, j = 0; i < n; ++i) {
int bit = n >> 1;
for (; j >= bit; bit >>= 1) j -= bit;
j += bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
long double ang = 2 * PI / len * (invert ? -1 : 1);
complex<long double> wlen(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
complex<long double> w(1);
for (int j = 0; j < len / 2; ++j) {
complex<long double> u = a[i + j], v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert)
for (int i = 0; i < n; ++i) a[i] /= n;
}
inline void input(int &a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline void out(long long a) {
if (!a) putchar('0');
if (a < 0) {
putchar('-');
a = -a;
}
char s[20];
int i;
for (i = 0; a; ++i) {
s[i] = '0' + a % 10;
a /= 10;
}
for (int j = (i)-1; j >= 0; j--) putchar(s[j]);
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
struct lnum {
vector<int> a;
int base;
lnum(int num = 0, int base = 1000000000) : base(base) {
if (!num) a.resize(1);
while (num) {
a.push_back(num % base);
num /= base;
}
}
inline int len() const { return a.size(); }
lnum &operator=(const lnum &l) {
if (this != &l) {
a = l.a;
base = l.base;
}
return *this;
}
inline friend lnum operator+(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int ln = l.len(), rn = r.len();
int n = max(ln, rn);
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = o;
if (i < ln) s += l.a[i];
if (i < rn) s += r.a[i];
o = s >= base;
if (o) s -= base;
ret.a[i] = s;
}
if (o) ret.a.push_back(1);
return ret;
}
inline friend lnum operator-(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int n = l.len();
int rn = r.len();
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = l.a[i] - o;
if (i < rn) s -= r.a[i];
o = s < 0;
if (o) s += base;
ret.a[i] = s;
}
if (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator*(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
if (l.len() * r.len() > 1000000) {
vector<complex<long double> > fa(l.a.begin(), l.a.end()),
fb(r.a.begin(), r.a.end());
int n = 1;
while (n < max(l.len(), r.len())) n <<= 1;
n <<= 1;
fa.resize(n), fb.resize(n);
fft(fa, false), fft(fb, false);
for (int i = 0; i < n; ++i) fa[i] *= fb[i];
fft(fa, true);
ret.a.resize(n);
for (int i = 0; i < n; ++i) ret.a[i] = int(fa[i].real() + 0.5);
int carry = 0;
for (int i = 0; i < n; ++i) {
ret.a[i] += carry;
carry = ret.a[i] / base;
ret.a[i] %= base;
}
} else {
ret.a.resize(l.len() + r.len());
for (int i = 0; i < l.len(); ++i)
for (int j = 0, carry = 0; j < r.len() || carry; ++j) {
long long cur = ret.a[i + j] +
(long long)l.a[i] * (j < r.len() ? r.a[j] : 0) +
carry;
ret.a[i + j] = cur % base;
carry = cur / base;
}
}
while (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator/(const lnum &l, const int &r) {
lnum ret(0, l.base);
ret.a.resize(l.len());
int carry = 0;
for (int i = l.len() - 1; i >= 0; --i) {
long long cur = l.a[i] + (long long)carry * l.base;
ret.a[i] = cur / r;
carry = cur % r;
}
while (ret.len() > 1 && ret.a.back() == 0) ret.a.pop_back();
return ret;
}
inline friend bool operator<(const lnum &l, const lnum &r) {
if (l.len() < r.len()) return true;
if (l.len() > r.len()) return false;
int n = l.len();
for (int i = n - 1; i >= 0; --i) {
if (l.a[i] < r.a[i]) return true;
if (l.a[i] > r.a[i]) return false;
}
return false;
}
inline friend bool operator>(const lnum &l, const lnum &r) { return r < l; }
inline friend bool operator==(const lnum &l, const lnum &r) {
if (l.len() != r.len()) return false;
int n = l.len();
for (int i = n - 1; i; --i) {
if (l.a[i] != r.a[i]) return false;
}
return true;
}
inline friend bool operator!=(const lnum &l, const lnum &r) {
return !(l == r);
}
inline void print() {
if (base == 1000000000) {
printf("%d", a.back());
for (int i = a.size() - 2; i >= 0; --i) printf("%09d", a[i]);
} else {
for (int i = a.size() - 1; i >= 0; --i) printf("%d", a[i]);
}
}
};
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int main() {
int(n);
input((n));
;
int(m);
input((m));
;
int(k);
input((k));
;
int b[26];
memset((b), 0, sizeof(b));
for (int i = 0; i < (int)(k); i++) b[i] = 1;
reverse(b, b + 26);
string ss[n];
for (int i = 0; i < (int)(n); i++) cin >> ss[i];
pair<int, int> s, f;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(m); j++) {
if (ss[i][j] == 'S') s = make_pair(i, j);
if (ss[i][j] == 'T') f = make_pair(i, j);
}
string ans;
int best = INF;
do {
int d[n][m];
memset(d, 255, sizeof(d));
queue<pair<int, int> > q;
q.push(f);
d[f.first][f.second] = 0;
while (!q.empty()) {
pair<int, int> v = q.front();
q.pop();
for (int i = 0; i < (int)(4); i++) {
int first = v.first + dx[i];
int second = v.second + dy[i];
if (first >= 0 && first < n && second >= 0 && second < m &&
d[first][second] == -1 &&
(ss[first][second] == 'S' || b[ss[first][second] - 'a'])) {
d[first][second] = d[v.first][v.second] + 1;
q.push(make_pair(first, second));
}
}
}
if (d[s.first][s.second] == -1 || d[s.first][s.second] > best) continue;
vector<pair<int, int> > Q;
Q.push_back(s);
char used[n][m];
memset((used), 0, sizeof(used));
used[s.first][s.second] = 1;
string cur;
while (1) {
vector<pair<int, int> > QQ;
char min_c = 'z' + 1;
for (int t = 0; t < (int)(Q.size()); t++) {
pair<int, int> v = Q[t];
for (int i = 0; i < (int)(4); i++) {
int first = v.first + dx[i];
int second = v.second + dy[i];
if (first >= 0 && first < n && second >= 0 && second < m &&
d[first][second] == d[v.first][v.second] - 1 &&
(ss[first][second] == 'T' || b[ss[first][second] - 'a'])) {
if (ss[first][second] < min_c) {
QQ.clear();
min_c = ss[first][second];
}
if (ss[first][second] == min_c && !used[first][second]) {
QQ.push_back(make_pair(first, second));
used[first][second] = 1;
}
}
}
}
if (min_c == 'T')
break;
else {
Q = QQ;
cur += min_c;
}
}
if (d[s.first][s.second] < best) {
ans = cur;
best = d[s.first][s.second];
} else {
((ans) = (cur) < (ans) ? (cur) : (ans));
}
} while (next_permutation(b, b + 26));
if (best == INF)
puts("-1");
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename C>
ostream& operator<<(ostream& os, const vector<C>& v) {
for (__typeof((v).begin()) __it = (v).begin(); __it != (v).end(); __it++)
os << *(__it) << ' ';
return os;
}
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
const int maxn = 52;
char field[maxn][maxn];
int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
vector<pair<int, int> > q[maxn * maxn * 4];
bool visit[maxn][maxn];
pair<int, int> from[maxn][maxn];
int n, m, k;
pair<int, int> start, finish;
int letter_can[26];
int letter_canf[26];
inline bool check(const pair<int, int>& p) {
if (p.first < 0 || p.first >= n) return false;
if (p.second < 0 || p.second >= m) return false;
return true;
}
char seq[5];
int can_start, can_finish;
bool finalresset;
string finalres;
void dfs(int letter, int curk) {
if (curk < k) {
for (int i = letter; i <= 'z'; i++) {
seq[curk] = i;
letter_canf[i - 'a']++;
if (letter_can[i - 'a'] / 10) can_start++;
if (letter_can[i - 'a'] % 10) can_finish++;
dfs(i, curk + 1);
if (letter_can[i - 'a'] / 10) can_start--;
if (letter_can[i - 'a'] % 10) can_finish--;
letter_canf[i - 'a']--;
}
return;
}
if (can_start * can_finish == 0) return;
;
int bc = 0;
int fr = 1;
memset(visit, 0, sizeof(visit));
q[0].clear();
visit[start.first][start.second] = true;
q[0].push_back(start);
from[finish.first][finish.second] = pair<int, int>(-1, -1);
while (bc < fr) {
;
;
vector<pair<int, int> >& c = q[bc++];
vector<pair<int, int> > qnext[4];
for (int i = 0; i < (int((c).size())); i++) {
;
for (int j = 0; j < 4; j++) {
;
pair<int, int> next = c[i];
next.first += dir[j][0];
next.second += dir[j][1];
if (!check(next)) continue;
char nextc = field[next.first][next.second];
;
if ((letter_canf[nextc - 'a'] || nextc == 'T') &&
!visit[next.first][next.second]) {
visit[next.first][next.second] = true;
from[next.first][next.second] = c[i];
if (nextc == 'T') continue;
int w;
for (w = 0; seq[w] != nextc; w++)
;
qnext[w].push_back(next);
}
}
}
for (int i = 0; i < 4; i++)
if (qnext[i].size()) q[fr++] = qnext[i];
};
if (from[finish.first][finish.second] == pair<int, int>(-1, -1)) return;
string res;
pair<int, int> cur = from[finish.first][finish.second];
while (cur != start) {
res += field[cur.first][cur.second];
cur = from[cur.first][cur.second];
}
reverse(res.begin(), res.end());
if (!finalresset || (int((res).size())) < (int((finalres).size())) ||
((int((res).size())) == (int((finalres).size())) && res < finalres)) {
finalres = res;
finalresset = true;
}
return;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%s", field[i]);
for (int j = 0; j < m; j++)
if (field[i][j] == 'S')
start = pair<int, int>(i, j);
else if (field[i][j] == 'T')
finish = pair<int, int>(i, j);
}
for (int i = 0; i < 4; i++) {
pair<int, int> next = start;
next.first += dir[i][0];
next.second += dir[i][1];
if (next == finish) {
cout << endl;
return 0;
}
if (check(next) && next != finish) {
letter_can[field[next.first][next.second] - 'a'] += 10;
}
next = finish;
next.first += dir[i][0];
next.second += dir[i][1];
if (check(next) && next != start) {
letter_can[field[next.first][next.second] - 'a'] += 1;
}
}
dfs('a', 0);
if (finalresset)
cout << finalres << endl;
else
cout << -1 << endl;
return 0;
}
|
#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, 0, 1, 0};
const int dy[4] = {0, 1, 0, -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>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
int n, m, k, x, y, xx, yy;
int A[64][64];
string T[64];
vector<int> M;
pair<int, int> P[51][51];
bool B[51][51];
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
int l, r;
void G(int i, int c, int mask, bool ok) {
if (c > 0 && c <= k && ok) M.push_back(mask);
if (i < 26) G(i + 1, c, mask, false);
if (c < k && i < 26) G(i + 1, c + 1, (mask | (1 << i)), true);
}
bool ok(int x, int y) { return (x >= 0 && y >= 0 && x < n && y < m); }
pair<pair<int, char>, pair<pair<int, int>, pair<int, int> > > Q[10000];
void add(int x, int y, int t) {
r++;
Q[r] = make_pair(make_pair(t, T[x][y]),
make_pair(make_pair(x, y), make_pair(0, 0)));
}
bool comp(pair<pair<int, char>, pair<pair<int, int>, pair<int, int> > > a,
pair<pair<int, char>, pair<pair<int, int>, pair<int, int> > > b) {
if (a.first.second < b.first.second) return true;
if (a.first.second > b.first.second) return false;
return (a.second.second.first < b.second.second.first);
}
int main() {
cin >> n >> m >> k;
for (int(i) = (0); (i) < (n); ++(i)) cin >> T[i];
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (m); ++(j)) {
if (T[i][j] == 'T') {
x = i;
y = j;
} else if (T[i][j] == 'S') {
xx = i;
yy = j;
}
}
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (m); ++(j))
if (T[i][j] != 'S' && T[i][j] != 'T') A[i][j] = T[i][j] - 'a';
G(0, 0, 0, false);
string res = "-1";
for (int(i) = (0); (i) < (M.size()); ++(i)) {
int mask = M[i];
memset(B, false, sizeof(B));
for (int(j) = (0); (j) < (n); ++(j))
for (int(l) = (0); (l) < (m); ++(l)) P[j][l] = make_pair(-1, -1);
B[x][y] = true;
l = 0, r = -1;
add(x, y, 0);
Q[0].second.second.first = 0;
int last = -1;
while (l <= r) {
pair<int, int> t;
pair<int, char> q;
t = Q[l].second.first;
q = Q[l].first;
if (q.first != last) {
int j = 1;
while (l + j <= r && q.first == Q[l + j].first.first) j++;
for (int(y) = (l); (y) < (l + j); ++(y)) Q[y].second.second.first = y;
sort(Q + l, Q + l + j, comp);
}
last = q.first;
t = Q[l].second.first;
q = Q[l].first;
l++;
if (t == make_pair(xx, yy)) break;
for (int(j) = (0); (j) < (4); ++(j)) {
int tx = t.first + dx[j], ty = t.second + dy[j];
if (!ok(tx, ty)) continue;
if (B[tx][ty]) continue;
if (T[tx][ty] != 'S' && T[tx][ty] != 'T' &&
(mask & (1 << A[tx][ty])) == 0)
continue;
B[tx][ty] = true;
P[tx][ty] = t;
add(tx, ty, q.first + 1);
}
}
pair<int, int> t;
t = make_pair(xx, yy);
if (!B[xx][yy]) continue;
string s = "";
while (P[t.first][t.second] != make_pair(x, y)) {
int tx = P[t.first][t.second].first;
int ty = P[t.first][t.second].second;
s += T[tx][ty];
t.first = tx;
t.second = ty;
}
if (res == "-1" || s.size() < res.size() ||
(s.size() == res.size() && s < res))
res = s;
}
cout << res << endl;
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
int n, m, k;
char A[64][64];
int d[4];
char bestpath[3000];
int bestlen = -1;
int sx = -1, sy = -1, tx = -1, ty = -1;
int kolejka[3000];
int kval[100][100];
int prev[100][100];
int ks, kk;
int main(void) {
memset(A, 0, sizeof(A));
scanf("%d %d %d", &n, &m, &k);
int i, j;
for (i = 1; i <= n; i++) {
scanf("%s", &A[i][1]);
for (j = 1; j <= m; j++) {
if (A[i][j] == 'S') {
sy = i;
sx = j;
}
if (A[i][j] == 'T') {
ty = i;
tx = j;
}
}
}
*bestpath = 0;
for (d[0] = 'a'; d[0] <= 'z'; d[0]++)
for (d[1] = d[0]; d[1] <= 'z'; d[1]++)
for (d[2] = d[1]; d[2] <= 'z'; d[2]++)
for (d[3] = d[2]; d[3] <= 'z'; d[3]++) {
int diff = 0;
int used[300];
memset(used, 0, sizeof(used));
for (i = 0; i < 4; i++) {
if (used[d[i]] == 0) {
diff++;
}
used[d[i]] = 1;
}
if (diff > k) {
continue;
}
used['T'] = 1;
memset(kval, 0xff, sizeof(kval));
ks = kk = 0;
kval[sy][sx] = 0;
kolejka[kk++] = sy * 100 + sx;
int currentlen = -1;
int inklen = 0;
int ddy[4] = {0, -1, 0, 1};
int ddx[4] = {-1, 0, 1, 0};
while (ks != kk) {
int p = kolejka[ks];
int py = p / 100;
int px = p % 100;
ks++;
if (px == tx && py == ty) {
currentlen = kval[py][px];
break;
}
for (i = 0; i < 4; i++) {
int nx = px + ddx[i];
int ny = py + ddy[i];
if (!used[A[ny][nx]]) {
continue;
}
if (kval[ny][nx] != -1) {
continue;
}
prev[ny][nx] = p;
kval[ny][nx] = kval[py][px] + 1;
kolejka[kk++] = ny * 100 + nx;
}
}
if (currentlen != -1) {
}
if (currentlen != -1 &&
(bestlen == -1 || currentlen - 1 <= bestlen)) {
currentlen--;
char tpath[3000];
memset(tpath, '-', sizeof(tpath));
tpath[currentlen] = 0;
int ts = 0, te = 0;
int avail[64][64], good[64][64];
memset(avail, 0, sizeof(avail));
memset(good, 0, sizeof(good));
avail[sy][sx] = 1;
good[ty][tx] = 1;
int kolejka2[3000];
int ks2, ke2;
ks2 = ke2 = 0;
kolejka2[ke2++] = ty * 100 + tx;
good[ty][tx] = 1;
while (ks2 != ke2) {
int p = kolejka2[ks2++];
int py = p / 100;
int px = p % 100;
int k;
for (k = 0; k < 4; k++) {
int nx = px + ddx[k];
int ny = py + ddy[k];
if (kval[ny][nx] == kval[py][px] - 1 && !good[ny][nx]) {
good[ny][nx] = 1;
kolejka2[ke2++] = ny * 100 + nx;
}
}
}
ts = 1;
for (i = 1; i <= currentlen; i++) {
te = ts;
while (te < kk &&
kval[kolejka[te] / 100][kolejka[te] % 100] == i) {
te++;
}
bool found = false;
for (j = 'a'; j <= 'z'; j++) {
if (used[j]) {
int s;
for (s = ts; s <= te - 1; s++) {
int p = kolejka[s];
int py = p / 100;
int px = p % 100;
if (A[py][px] != j) {
continue;
}
if (!good[py][px]) {
continue;
}
int k;
for (k = 0; k < 4; k++) {
int nx = px + ddx[k];
int ny = py + ddy[k];
if (kval[ny][nx] == i - 1 && avail[ny][nx]) {
avail[py][px] = 1;
found = true;
}
}
}
}
if (found) {
break;
}
}
tpath[i - 1] = j;
ts = te;
}
if (bestlen == -1 || currentlen < bestlen) {
bestlen = currentlen;
strcpy(bestpath, tpath);
} else {
if (strcmp(tpath, bestpath) < 0) {
strcpy(bestpath, tpath);
}
}
}
}
if (bestlen == -1) {
printf("-1\n");
} else {
printf("%s\n", bestpath);
}
return 0;
}
|
#include <bits/stdc++.h>
int n, m, u, v, cnt;
int pos[30], dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
char s[60][60], s2[3000], ans[3000], tmp[3000];
int d[3000], in[3000], next[3000], q[1000000 + 1], f, r, mind;
int cmp(int a, int b) {
int flag = 0;
while (a != -1 && b != -1) {
if (s2[a] < s2[b]) {
flag = -1;
break;
} else if (s2[a] > s2[b]) {
flag = 1;
break;
} else {
a = next[a];
b = next[b];
}
}
return flag;
}
void spfa(int M) {
int i, j, nc;
int cu, nv, x, y, nx, ny;
memset(d, -1, sizeof(d));
memset(in, 0, sizeof(in));
memset(next, -1, sizeof(next));
f = r = 0;
q[r++] = v;
d[v] = 0;
in[v] = 1;
while (f != r) {
cu = q[f];
in[cu] = 0;
f = (f + 1) % 1000000;
x = cu / m;
y = cu % m;
for (i = 0; i < 4; i++) {
nx = x + dir[i][0];
ny = y + dir[i][1];
nv = nx * m + ny;
if (0 <= nx && nx < n && 0 <= ny && ny < m &&
(nv == u || (M & (1 << pos[s2[nv] - 'a'])) != 0)) {
if (d[nv] == -1 || d[nv] > d[cu] + 1 ||
(d[nv] == d[cu] + 1 && cmp(cu, next[nv]) <= 0)) {
d[nv] = d[cu] + 1;
next[nv] = cu;
if (in[nv] == 0) {
in[nv] = 1;
q[r] = nv;
r = (r + 1) % 1000000;
}
}
}
}
}
if (d[u] != -1 && (mind == -1 || mind >= d[u])) {
cu = u;
j = 0;
while (cu != v && cu != -1) {
tmp[j++] = s2[cu];
cu = next[cu];
}
tmp[j] = '\0';
if (mind == -1 || mind > d[u] || (mind == d[u] && strcmp(tmp, ans) < 0)) {
strcpy(ans, tmp);
}
mind = d[u];
}
}
int mask[20000], mm;
void dfs(int i, int state, int k) {
if (k == 0) {
mask[mm++] = state;
return;
}
if (i < 0) {
return;
}
dfs(i - 1, state, k);
state = state | (1 << i);
dfs(i - 1, state, k - 1);
}
int main() {
int i, j, k;
while (scanf("%d%d%d", &n, &m, &k) == 3) {
cnt = 0;
memset(pos, -1, sizeof(pos));
for (i = 0; i < n; i++) {
scanf("%s", s[i]);
for (j = 0; j < m; j++) {
if (s[i][j] == 'S') {
u = i * m + j;
} else if (s[i][j] == 'T') {
v = i * m + j;
} else {
if (pos[s[i][j] - 'a'] == -1) {
pos[s[i][j] - 'a'] = cnt++;
}
}
s2[i * m + j] = s[i][j];
}
}
mm = 0;
for (i = 0; i <= k; i++) {
dfs(cnt - 1, 0, i);
}
mind = -1;
for (i = 0; i < mm; i++) {
spfa(mask[i]);
}
if (mind == -1) {
printf("-1\n");
} else {
puts(ans + 1);
}
}
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 (len != -1 && dist[r][c] > len + 1) break;
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 timer {
time_t start;
timer() { start = clock(); }
~timer() {
cerr << 1. * (clock() - start) / CLOCKS_PER_SEC << " secs" << endl;
}
};
int n, m, K;
char c[55][55];
int sy, sx, ty, tx;
map<int, string> d[55][55];
int dy[] = {0, 1, 0, -1};
int dx[] = {1, 0, -1, 0};
string shortest[55][55];
int smask[55][55];
struct state {
int y, x;
string s;
int mask;
state(int y, int x, string s, int mask) : y(y), x(x), s(s), mask(mask) {}
};
const bool operator<(const state& a, const state& b) {
return ((int)a.s.size()) > ((int)b.s.size()) ||
((int)a.s.size()) == ((int)b.s.size()) && a.s > b.s;
}
const bool better(string s, string t) {
return ((int)s.size()) < ((int)t.size()) ||
((int)s.size()) == ((int)t.size()) && s < t;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m >> K;
for (int i = 1; i < (n + 1); i++)
for (int j = 1; j < (m + 1); j++) {
cin >> c[i][j];
if (c[i][j] == 'S') sy = i, sx = j;
if (c[i][j] == 'T') ty = i, tx = j;
}
for (int i = 1; i < (n + 1); i++)
for (int j = 1; j < (m + 1); j++) {
shortest[i][j] = string(n * m, '~');
}
d[sy][sx][0] = "";
priority_queue<state> Q;
Q.push(state(sy, sx, "", 0));
while (((int)Q.size())) {
state s = Q.top();
Q.pop();
if (s.y == ty && s.x == tx) {
cout << s.s.substr(0, ((int)s.s.size()) - 1);
return 0;
}
for (int i = 0; i < (4); i++) {
int ny = s.y + dy[i], nx = s.x + dx[i];
if (!c[ny][nx] || c[ny][nx] == 'S') continue;
if (c[ny][nx] != 'T' && __builtin_popcount(s.mask) == K &&
!(s.mask >> (c[ny][nx] - 'a') & 1))
continue;
string ndist = s.s + c[ny][nx];
int nmask = s.mask | (c[ny][nx] == 'T' ? 0 : 1 << (c[ny][nx] - 'a'));
if (!better(ndist, shortest[ny][nx]) &&
(smask[ny][nx] & nmask) == smask[ny][nx])
continue;
if (shortest[ny][nx][0] == '~') {
shortest[ny][nx] = ndist;
smask[ny][nx] = nmask;
}
if (d[ny][nx].find(nmask) == d[ny][nx].end() ||
better(ndist, d[ny][nx][nmask])) {
d[ny][nx][nmask] = ndist;
Q.push(state(ny, nx, ndist, nmask));
}
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int S, T;
string s[55];
set<pair<int, int>> se;
int dist(int a, int b) { return abs(a / m - b / m) + abs(a % m - b % m); }
int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
void Dijstra() {
priority_queue<pair<pair<int, string>, pair<int, int>>,
vector<pair<pair<int, string>, pair<int, int>>>,
greater<pair<pair<int, string>, pair<int, int>>>>
Q;
Q.push({{dist(S, T), ""}, {0, S}});
pair<pair<int, string>, pair<int, int>> ss;
string str;
int book, pos;
int x, y, xx, yy;
while (!Q.empty()) {
ss = Q.top();
Q.pop();
str = ss.first.second;
book = ss.second.first;
pos = ss.second.second;
if (!se.count({book, pos})) {
se.insert({book, pos});
x = pos / m, y = pos % m;
for (int i = 0; i < 4; i++) {
xx = x + dir[i][0];
yy = y + dir[i][1];
if (xx >= 0 && xx < n && yy >= 00 && yy < m) {
if (s[xx][yy] == 'T') {
cout << str << endl;
exit(0);
}
if (__builtin_popcount(book | (1 << (s[xx][yy] - 'a'))) <= k)
Q.push({{dist(xx * m + yy, T) + str.length() + 1, str + s[xx][yy]},
{book | (1 << (s[xx][yy] - 'a')), xx * m + yy}});
}
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) {
if (s[i][j] == 'S') {
S = i * m + j;
}
if (s[i][j] == 'T') {
T = i * m + j;
}
}
}
Dijstra();
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string res;
int c[26], w[26];
bool vis[26];
int f[60][60];
char g[60][60];
int n, m, k, s1, s2, e1, e2, tot, step, maxstep;
int way[4][2] = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
struct In {
int l;
int r;
string ss;
} s[3000];
void bfs() {
memset(f, -1, sizeof(f));
int i, j, first = 0, last = 1, len = 1, move = 1, ll;
s[0].l = s1;
s[0].r = s2;
s[0].ss = "";
f[s1][s2] = 0;
string a;
bool z = false;
while (first < last) {
for (i = first; i < last; i++) {
for (j = 0; j < 4; j++) {
int p, q;
p = s[i].l + way[j][0];
q = s[i].r + way[j][1];
if (p >= 0 && p < n && q >= 0 && q < m) {
if (f[p][q] != -1 && f[p][q] < move) continue;
a = s[i].ss;
if (step == maxstep && a >= res) continue;
if (g[p][q] == 'T') {
if (res == "") {
res = a;
step = move;
} else {
int x1 = a.length(), x2 = res.length();
if (x1 < x2 || (x1 == x2 && a < res)) {
res = a;
if (move < step) step = move;
}
}
z = true;
} else if (!z) {
bool zz = false;
for (ll = 0; ll < tot && ll < k; ll++) {
if (w[ll] == g[p][q] - 'a') {
zz = true;
break;
}
}
if (zz) {
a += g[p][q];
for (ll = last; ll < len; ll++)
if (s[ll].l == p && s[ll].r == q) {
if (s[ll].ss > a) s[ll].ss = a;
break;
}
if (ll == len) {
s[len].l = p;
s[len].r = q;
s[len].ss = a;
len++;
f[p][q] = move;
}
}
}
}
}
}
if (z) break;
first = last;
last = len;
move++;
if (move > step) break;
}
}
void dfs(int x, int y) {
if (x == tot) return;
w[y] = c[x];
if (y == k - 1) {
bfs();
} else
dfs(x + 1, y + 1);
dfs(x + 1, y);
}
int main() {
while (cin >> n >> m >> k) {
int i, j;
tot = 0;
memset(vis, 0, sizeof(vis));
for (i = 0; i < n; i++) {
cin >> g[i];
for (j = 0; j < m; j++) {
if (g[i][j] == 'S') {
s1 = i;
s2 = j;
} else if (g[i][j] == 'T') {
e1 = i;
e2 = j;
} else if (g[i][j] >= 'a' && g[i][j] <= 'z') {
if (!vis[g[i][j] - 'a']) {
c[tot++] = g[i][j] - 'a';
vis[g[i][j] - 'a'] = 1;
}
}
}
}
maxstep = abs(s1 - e1) + abs(s2 - e2);
step = 3000;
if (tot <= k) {
for (i = 0; i < tot; i++) w[i] = c[i];
bfs();
} else
dfs(0, 0);
if (step == 3000)
cout << -1 << endl;
else
cout << res << 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][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;
}
}
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;
set<int> was;
pair<int, int> pr[55][55];
int ds[55][55];
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
char a[55][55];
int n, m, k, si, sj, fi, fj;
string ans = "";
bool ex = 0;
inline bool ok(int i, int j) { return (i >= 0 && i < n && j >= 0 && j < m); }
void go(int mask, int cnt) {
if (was.find(mask) != was.end()) return;
was.insert(mask);
for (int(move) = 0; (move) < (1); ++(move)) {
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j)) ds[i][j] = 1000000000;
queue<pair<int, int> > q;
q.push(make_pair(fi, fj));
ds[fi][fj] = 0;
while (!q.empty()) {
pair<int, int> cur = q.front();
q.pop();
for (int(l) = 0; (l) < (4); ++(l))
if (ok(cur.first + dx[l], cur.second + dy[l]) &&
ds[cur.first + dx[l]][cur.second + dy[l]] == 1000000000)
if (a[cur.first + dx[l]][cur.second + dy[l]] == 'S' ||
(mask &
(1 << (a[cur.first + dx[l]][cur.second + dy[l]] - 'a')))) {
ds[cur.first + dx[l]][cur.second + dy[l]] =
ds[cur.first][cur.second] + 1;
q.push(make_pair(cur.first + dx[l], cur.second + dy[l]));
}
}
if (ds[si][sj] == 1000000000) break;
if (ex && ds[si][sj] - 1 > (int)ans.size()) break;
string cur = "";
int step = ds[si][sj];
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j))
if (ds[i][j] == step && (i != si || j != sj)) ds[i][j] = -1;
while (step > 1) {
char bst = 'z';
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j))
if (ds[i][j] == step)
for (int(l) = 0; (l) < (4); ++(l))
if (ok(i + dx[l], j + dy[l]) &&
ds[i + dx[l]][j + dy[l]] == ds[i][j] - 1)
bst = min(bst, a[i + dx[l]][j + dy[l]]);
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j))
if (ds[i][j] == step - 1) {
bool can = 0;
for (int(l) = 0; (l) < (4); ++(l))
if (ok(i + dx[l], j + dy[l]) && ds[i + dx[l]][j + dy[l]] == step)
can = 1;
if (a[i][j] != bst) can = 0;
if (!can) ds[i][j] = -1;
}
cur += bst;
--step;
}
if (!ex || ((int)cur.size() < (int)ans.size()) ||
((int)cur.size() == (int)ans.size() && cur < ans)) {
ex = 1;
ans = cur;
}
}
if (cnt < k)
for (int(i) = 0; (i) < (26); ++(i))
if (!(mask & (1 << i))) go(mask | (1 << i), cnt + 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];
if (a[i][j] == 'S')
si = i, sj = j;
else if (a[i][j] == 'T')
fi = i, fj = j;
}
go(0, 0);
if (ex)
cout << ans << endl;
else
cout << "-1\n";
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long S = 0;
char ch = ' ';
bool f = 0;
while (!isdigit(ch)) {
f |= (ch == '-');
ch = getchar();
}
while (isdigit(ch)) {
S = (S << 3) + (S << 1) + (ch - '0');
ch = getchar();
}
return (f) ? (-S) : (S);
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10) {
putchar(x + '0');
return;
}
write(x / 10);
putchar(x % 10 + '0');
}
const int N = 55;
int n, m, k, can[N][N];
char a[N][N];
int dx[] = {-1, 0, 0, 1}, dy[] = {0, -1, 1, 0};
struct node {
int x, y, lim;
string jyl;
inline bool operator<(const node &tmp) const {
return (tmp.jyl.size() != jyl.size()) ? (tmp.jyl.size() < jyl.size())
: (tmp.jyl < jyl);
}
};
priority_queue<node> que;
set<int> arr[N][N];
inline int js(int x) {
int i, jyl = 0;
for (i = 0; i <= 25; i++)
if (x & (1 << i)) jyl++;
return jyl;
}
int main() {
int i, j, o, x, y, lim;
n = read();
m = read();
k = read();
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (a[i][j] == 'S') {
que.push((node){i, j, 0, ""});
while (!que.empty()) {
node now = que.top();
que.pop();
for (o = 0; o < 4; o++) {
x = now.x + dx[o];
y = now.y + dy[o];
if (x < 0 || y < 0 || x >= n || y >= m || a[x][y] == 'S') continue;
if (a[x][y] == 'T') {
cout << now.jyl << endl;
return 0;
}
lim = now.lim | (1 << (a[x][y] - 'a'));
if (js(lim) > k || arr[x][y].count(lim)) continue;
if (can[x][y] && (can[x][y] & lim) == can[x][y]) continue;
can[x][y] = lim;
arr[x][y].insert(lim);
que.push((node){x, y, lim, now.jyl + a[x][y]});
}
}
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
int mul(int a, int b) { return 1ll * a * b % P; }
int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
const int N = 51;
int ans2, n, m, k, use[1000], d[N][N];
string ans, a[N], ss[N][N];
queue<pair<int, int> > q;
pair<int, int> s, t;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
void solve() {
memset(d, 0, sizeof(d));
q.push(s);
d[s.first][s.second] = 1;
ss[t.first][t.second] = "S";
while (!q.empty()) {
auto tmp = q.front();
q.pop();
int x = tmp.first, y = tmp.second;
for (int i = (0); i < (4); i++) {
int xx = x + dx[i], yy = y + dy[i];
if (xx > n || xx < 1 || yy > m || yy < 1 || !use[a[xx][yy]]) continue;
if (xx == t.first && yy == t.second) {
if (!d[xx][yy]) d[xx][yy] = d[x][y] + 1;
if (d[xx][yy] != d[x][y] + 1) continue;
if (ss[xx][yy] == "S")
ss[xx][yy] = ss[x][y];
else
ss[xx][yy] = min(ss[xx][yy], ss[x][y]);
continue;
}
if (!d[xx][yy]) {
d[xx][yy] = d[x][y] + 1;
ss[xx][yy] = ss[x][y] + a[xx][yy];
q.push(make_pair(xx, yy));
} else if (d[xx][yy] == d[x][y] + 1)
ss[xx][yy] = min(ss[x][y] + a[xx][yy], ss[xx][yy]);
}
}
if (d[t.first][t.second] == 0) return;
if (d[t.first][t.second] < ans2) {
ans2 = d[t.first][t.second];
ans = ss[t.first][t.second];
}
if (d[t.first][t.second] > ans2) return;
ans = min(ans, ss[t.first][t.second]);
}
void dfs(int d, int now) {
if (d == k + 1) {
solve();
return;
}
for (int i = (now); i < ('z' + 1); i++) {
use[i] = 1;
dfs(d + 1, i + 1);
use[i] = 0;
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> m >> k;
for (int i = (1); i < (n + 1); i++) cin >> a[i], a[i] = " " + a[i];
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++)
if (a[i][j] == 'S')
s = make_pair(i, j);
else if (a[i][j] == 'T')
t = make_pair(i, j);
use['T'] = 1;
ans2 = (1ll << (30));
ans = "S";
dfs(1, 'a');
if (ans == "S")
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50 + 5;
int R, C, K;
char g[maxn][maxn];
int sx, sy, tx, ty;
bool flag[300];
int mindist;
string ans;
const int dx[] = {0, 1, -1, 0};
const int dy[] = {1, 0, 0, -1};
bool mark[maxn][maxn];
int dist[maxn][maxn];
string board[maxn][maxn];
set<pair<int, int> > grid[maxn * maxn];
void calc() {
memset(dist, -1, sizeof dist);
memset(mark, false, sizeof mark);
queue<pair<int, int> > q;
dist[tx][ty] = 0;
board[tx][ty] = "";
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 xx = x + dx[i], yy = y + dy[i];
if (xx >= 0 && xx < R && yy >= 0 && yy < C &&
(flag[g[xx][yy]] || g[xx][yy] == 'S')) {
if (dist[xx][yy] == -1) {
dist[xx][yy] = dist[x][y] + 1;
q.push(make_pair(xx, yy));
}
}
}
}
if (dist[sx][sy] == -1) return;
string ret = "";
int curd = dist[sx][sy];
grid[curd].clear();
grid[curd].insert(make_pair(sx, sy));
while (curd > 0) {
char best = 'z' + 1;
for (set<pair<int, int> >::iterator it = grid[curd].begin();
it != grid[curd].end(); ++it) {
for (int i = 0; i < 4; ++i) {
int xx = it->first + dx[i], yy = it->second + dy[i];
if (xx >= 0 && xx < R && yy >= 0 && yy < C &&
dist[xx][yy] + 1 == curd) {
if (g[xx][yy] < best) {
best = g[xx][yy];
grid[curd - 1].clear();
grid[curd - 1].insert(make_pair(xx, yy));
} else if (best == g[xx][yy]) {
grid[curd - 1].insert(make_pair(xx, yy));
}
}
}
}
ret += best;
curd--;
}
ret = ret.substr(0, (int)ret.size() - 1);
if (mindist == -1 || dist[sx][sy] < mindist ||
dist[sx][sy] == mindist && ret < ans) {
ans = ret;
mindist = dist[sx][sy];
}
}
void dfs(int dep, int last) {
if (last == 26) {
if (dep == 0) {
calc();
}
return;
}
dfs(dep, last + 1);
if (dep > 0) {
flag['a' + last] = 1;
dfs(dep - 1, last + 1);
flag['a' + last] = 0;
}
}
int main() {
scanf("%d%d%d", &R, &C, &K);
for (int i = 0; i < R; ++i) {
scanf("%s", g[i]);
}
for (int i = 0; i < R; ++i) {
for (int j = 0; j < C; ++j) {
if (g[i][j] == 'S') {
sx = i;
sy = j;
}
if (g[i][j] == 'T') {
tx = i;
ty = j;
}
}
}
if (abs(sx - tx) + abs(tx - ty) == 1) {
puts("");
return 0;
}
ans = "";
mindist = -1;
memset(flag, 0, sizeof flag);
dfs(K, 0);
if (mindist == -1) {
printf("%d\n", -1);
} else {
puts(ans.c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 64;
const int inf = 0x3f3f3f3f;
int n, m, k;
int sx, sy, tx, ty;
char mat[maxn][maxn];
bool allow[128];
struct point {
int x, y, pre;
point(int xx = 0, int yy = 0, int pp = 0) : x(xx), y(yy), pre(pp) {}
friend bool operator<(const point& lhs, const point& rhs) {
return (lhs.pre != rhs.pre) ? lhs.pre < rhs.pre
: mat[lhs.x][lhs.y] < mat[rhs.x][rhs.y];
}
};
int prex[maxn][maxn];
int prey[maxn][maxn];
int dist[maxn][maxn];
int dx[4] = {-1, 0, 0, 1};
int dy[4] = {0, -1, 1, 0};
void bfs() {
memset(dist, 63, sizeof(dist));
vector<point> U, V;
dist[sx][sy] = 0;
U.push_back(point(sx, sy, 0));
int cnt = 0;
while (!U.empty()) {
sort(U.begin(), U.end());
for (int i = 0, mxRank = 0; i < U.size(); ++i) {
point u = U[i];
if (i != 0 && (mat[U[i].x][U[i].y] != mat[U[i - 1].x][U[i - 1].y] ||
U[i].pre != U[i - 1].pre))
++mxRank;
for (int j = 0; j < 4; ++j) {
point v(u.x + dx[j], u.y + dy[j], mxRank);
if (dist[v.x][v.y] == inf && allow[mat[v.x][v.y]]) {
V.push_back(v);
dist[v.x][v.y] = dist[u.x][u.y] + 1;
prex[v.x][v.y] = u.x;
prey[v.x][v.y] = u.y;
}
if (v.x == tx && v.y == ty) return;
}
}
U.swap(V);
V.clear();
}
}
int main() {
int ans = inf;
vector<string> s;
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> mat[i][j];
if (mat[i][j] == 'S') {
sx = i;
sy = j;
} else if (mat[i][j] == 'T') {
tx = i;
ty = j;
}
}
}
allow['T'] = true;
for (char l1 = 'a'; l1 <= 'z'; ++l1) {
for (char l2 = l1; l2 <= 'z'; ++l2) {
for (char l3 = l2; l3 <= 'z'; ++l3) {
for (char l4 = l3; l4 <= 'z'; ++l4) {
int cnt = 1;
if (l2 != l1) ++cnt;
if (l3 != l2) ++cnt;
if (l4 != l3) ++cnt;
if (cnt > k) continue;
allow[l1] = allow[l2] = allow[l3] = allow[l4] = true;
bfs();
allow[l1] = allow[l2] = allow[l3] = allow[l4] = false;
if (dist[tx][ty] > ans || dist[tx][ty] == inf) continue;
if (dist[tx][ty] < ans) {
ans = dist[tx][ty];
s.clear();
}
int fx = tx, fy = ty, ffx, ffy;
string tmps;
while (true) {
ffx = prex[fx][fy];
ffy = prey[fx][fy];
fx = ffx;
fy = ffy;
if (fx == sx && fy == sy) break;
tmps = mat[fx][fy] + tmps;
}
s.push_back(tmps);
}
}
}
}
if (ans != inf) {
sort(s.begin(), s.end());
for (int i = 0; i < s[0].size(); ++i) cout << (s[0][i]);
cout << endl;
} else {
cout << EOF << endl;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
const long long int INF = 10000;
int n, m, k, fx, fy, tx, ty;
pair<int, int> gone[4] = {make_pair(0, 1), make_pair(0, -1), make_pair(1, 0),
make_pair(-1, 0)};
bool correct(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
int ma[51][51];
int dest[51][51];
int check[51][51];
int used[51][51];
void ch_dfs(int x, int y) {
if (dest[x][y] == INF) return;
used[x][y]++;
for (int i = 0; i < (4); i++) {
int tox = x + gone[i].first;
int toy = y + gone[i].second;
if (correct(tox, toy) && !used[tox][toy] &&
dest[tox][toy] == dest[x][y] - 1) {
check[tox][toy] = check[x][y] + 1;
ch_dfs(tox, toy);
}
}
}
bool comp(string &f, string &s) {
if (s == "-") return true;
return (f.length() < s.length() || (f.length() == s.length() && f < s));
}
string minans = "-";
pair<int, int> par[51][51];
void dfs(int x, int y) {
string cur = "";
vector<pair<int, pair<int, int> > > nex, f;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++) {
par[i][j] = make_pair(-1, -1);
}
f.push_back(make_pair(ma[x][y], make_pair(x, y)));
while (!f.empty()) {
nex.clear();
for (int i = 0; i < ((int)f.size()); i++) {
if (i && f[i].first > f[i - 1].first) break;
x = f[i].second.first;
y = f[i].second.second;
used[x][y]++;
for (int i = 0; i < (4); i++) {
int tox = x + gone[i].first;
int toy = y + gone[i].second;
if (correct(tox, toy) &&
((check[tox][toy] != -1 && check[tox][toy] == check[x][y] - 1) ||
(tox == tx && toy == ty)) &&
!used[tox][toy]) {
par[tox][toy] = make_pair(x, y);
used[tox][toy]++;
nex.push_back(make_pair(ma[tox][toy], make_pair(tox, toy)));
}
}
}
sort(nex.begin(), nex.end());
f = nex;
}
x = tx;
y = ty;
while (x != -1) {
cur += (char)ma[x][y] + 'a';
int nx = par[x][y].first;
int ny = par[x][y].second;
x = nx;
y = ny;
}
reverse(cur.begin(), cur.end());
if (comp(cur, minans)) {
minans = cur;
}
}
void bfs(int x, int y, vector<int> &cur) {
map<int, int> good;
for (int i = 0; i < ((int)cur.size()); i++) {
good[cur[i]]++;
}
good[ma[x][y]]++;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++) {
dest[i][j] = INF;
check[i][j] = -1;
used[i][j] = 0;
}
dest[x][y] = 0;
dest[fx][fy] = 0;
queue<pair<int, int> > q;
q.push(make_pair(x, y));
while (!q.empty()) {
int xi = q.front().first;
int yi = q.front().second;
q.pop();
for (int i = 0; i < (4); i++) {
int tox = xi + gone[i].first;
int toy = yi + gone[i].second;
if (correct(tox, toy) &&
(good.count(ma[tox][toy]) || (tox == tx && toy == ty)) &&
dest[tox][toy] > dest[xi][yi] + 1) {
dest[tox][toy] = dest[xi][yi] + 1;
q.push(make_pair(tox, toy));
}
}
}
if (dest[tx][ty] == INF) return;
check[tx][ty] = 0;
ch_dfs(tx, ty);
memset(used, 0, sizeof used);
string curi = "";
curi += ((char)'a' + ma[x][y]);
dfs(x, y);
}
vector<pair<int, int> > fr;
void gen(int len, vector<int> &cur) {
if (!len) {
for (int i = 0; i < ((int)fr.size()); i++) {
bfs(fr[i].first, fr[i].second, cur);
}
return;
}
int fr = (!(int)cur.size() ? 0 : cur.back() + 1);
for (int i = fr; i <= 'z' - 'a'; i++) {
cur.push_back(i);
gen(len - 1, cur);
cur.pop_back();
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++) {
char c;
cin >> c;
ma[i][j] = c - 'a';
if (c == 'S') {
fx = i;
fy = j;
}
if (c == 'T') {
tx = i;
ty = j;
}
}
for (int i = 0; i < (4); i++) {
int tox = fx + gone[i].first;
int toy = fy + gone[i].second;
if (correct(tox, toy)) {
fr.push_back(make_pair(tox, toy));
}
}
vector<int> temp;
gen(k - 1, temp);
if (minans == "-")
cout << -1;
else {
minans.resize((int)minans.size() - 1);
cout << minans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1E-9;
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double PI = 2 * acos(.0);
char mapa[55][55];
int resp[55][55];
bool dk[55][55];
pair<int, int> path[55][55];
int n, m, kk;
int mx[4] = {0, 0, 1, -1};
int my[4] = {1, -1, 0, 0};
int xini, yini, xfin, yfin;
int checkmask = -1;
string recover(int x, int y) {
if (x == xini && y == yini) return "";
if (mapa[x][y] == 'S') return recover(path[x][y].first, path[x][y].second);
return mapa[x][y] + recover(path[x][y].first, path[x][y].second);
}
string bfs() {
string result = ">";
int len = INF;
for (int i = 0; i < 26; i++) {
for (int j = i; j < 26; j++) {
for (int k = j; k < 26; k++) {
for (int l = k; l < 26; l++) {
int mask = 0;
mask |= (1 << l);
if (kk > 1) mask |= (1 << k);
if (kk > 2) mask |= (1 << j);
if (kk > 3) mask |= (1 << i);
if (__builtin_popcount(mask) != kk) continue;
memset(resp, -1, sizeof(resp));
memset(dk, false, sizeof(dk));
if (checkmask == mask) continue;
resp[xini][yini] = 0;
queue<pair<int, int> > cola;
cola.push(make_pair(xini, yini));
while (!cola.empty()) {
int nx = cola.front().first;
int ny = cola.front().second;
cola.pop();
if (dk[nx][ny]) continue;
dk[nx][ny] = true;
if (resp[nx][ny] > len) break;
for (int i = 0; i < (int)(4); i++) {
int mmx = nx + mx[i];
int mmy = ny + my[i];
if (!(mmx >= 0 && mmx < n && mmy >= 0 && mmy < m)) continue;
int value = mapa[mmx][mmy] - 'a';
if (!(mask & (1 << value)) && mapa[mmx][mmy] != 'T' &&
mapa[mmx][mmy] != 'S')
continue;
if (resp[mmx][mmy] == -1) {
resp[mmx][mmy] = resp[nx][ny] + 1;
cola.push(make_pair(mmx, mmy));
path[mmx][mmy] = make_pair(nx, ny);
} else if (resp[mmx][mmy] == resp[nx][ny] + 1) {
int cur1x, cur1y, cur2x, cur2y;
cur1x = path[mmx][mmy].first;
cur1y = path[mmx][mmy].second;
cur2x = nx;
cur2y = ny;
while (mapa[cur1x][cur1y] == mapa[cur2x][cur2y]) {
int tmp = path[cur1x][cur1y].first;
cur1y = path[cur1x][cur1y].second;
cur1x = tmp;
tmp = path[cur2x][cur2y].first;
cur2y = path[cur2x][cur2y].second;
cur2x = tmp;
if ((cur1x == cur2x && cur1y == cur2y)) break;
}
if (mapa[cur1x][cur1y] >= mapa[cur2x][cur2y]) {
path[mmx][mmy] = make_pair(nx, ny);
}
}
}
}
if (resp[xfin][yfin] != -1) {
string aux = recover(xfin, yfin);
if (resp[xfin][yfin] < len) {
result = aux;
len = resp[xfin][yfin];
} else if (resp[xfin][yfin] == len) {
if (result == ">" || result > aux) result = aux;
}
}
checkmask = mask;
}
}
}
}
if (result == ">") return "-1";
return result;
}
int main() {
scanf("%d%d%d", &n, &m, &kk);
for (int i = 0; i < (int)(n); i++) {
scanf("%s", mapa[i]);
for (int j = 0; j < (int)(m); j++) {
if (mapa[i][j] == 'T') {
xini = i;
yini = j;
} else if (mapa[i][j] == 'S') {
xfin = i;
yfin = j;
}
}
}
cout << bfs() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bcount[1 << 12];
set<pair<int, int> > Set;
string Map[60];
int n, m, k;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int ex, ey;
int dist(int ax, int ay, int bx, int by) { return abs(ax - bx) + abs(ay - by); }
struct Node {
int x, y;
string S;
int mask;
bool operator<(const Node &b) const {
if (S.size() + dist(x, y, ex, ey) == b.S.size() + dist(b.x, b.y, ex, ey))
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 = 0; 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<Node> q;
q.push((Node){x, y, "", 0});
bool found = false;
while (!q.empty()) {
Node cur = q.top();
q.pop();
if (cur.x == ex && cur.y == ey) {
cout << cur.S << endl;
found = true;
break;
}
if (Set.find(make_pair(cur.x * m + cur.y, cur.mask)) != Set.end()) continue;
Set.insert(make_pair(cur.x * m + cur.y, cur.mask));
for (int d = 0; d < 4; d++) {
Node 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>
int IntMaxVal = (int)1e20;
int IntMinVal = (int)-1e20;
long long LongMaxVal = (long long)1e20;
long long LongMinVal = (long long)-1e20;
using namespace std;
template <typename T>
struct argument_type;
template <typename T, typename U>
struct argument_type<T(U)> {};
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& s) {
is >> s.first >> s.second;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) os << v[i] << ' ';
os << '\n';
;
return os;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& s, pair<T1, T2>& t) {
s << t.first << ' ' << t.second;
return s;
}
template <typename T>
vector<T> readVector(int n) {
vector<T> res(n);
for (int i = 0; i < n; i++) cin >> res[i];
return res;
}
vector<string> f;
int n, m;
int sx, sy;
int ex, ey;
int wayLen[50][50];
bool visited[50][50];
class wayNode {
public:
vector<pair<char, char> > positions;
int cameFrom;
char cameBy;
};
vector<wayNode> q(2501);
inline void tryQueue(int destIndex, int y, int x, char c) {
if (y < 0 || x < 0 || y == n || x == m || (f[y][x] != c && f[y][x] != 'T') ||
visited[y][x])
return;
q[destIndex].positions.push_back(make_pair((char)y, (char)x));
visited[y][x] = true;
}
inline void tryQueue(int curIndex, int& destIndex, char c) {
for (auto& pos : q[curIndex].positions) {
tryQueue(destIndex, pos.first - 1, pos.second, c);
tryQueue(destIndex, pos.first + 1, pos.second, c);
tryQueue(destIndex, pos.first, pos.second - 1, c);
tryQueue(destIndex, pos.first, pos.second + 1, c);
}
if (q[destIndex].positions.size()) {
q[destIndex].cameBy = c;
q[destIndex].cameFrom = curIndex;
destIndex++;
q[destIndex].positions.clear();
}
}
vector<char> path;
string getAns(char c1, char c2, char c3, char c4) {
for (int y = 0; y < n; ++y)
for (int x = 0; x < m; ++x) wayLen[y][x] = -1;
for (int y = 0; y < n; ++y)
for (int x = 0; x < m; ++x) visited[y][x] = false;
int nextP = 0;
q[nextP].positions.clear();
q[nextP].positions.push_back(make_pair(sy, sx));
q[nextP].cameFrom = -1;
visited[sy][sx] = true;
nextP++;
q[nextP].positions.clear();
if (c2 < c1) swap(c1, c2);
if (c3 < c2) swap(c2, c3);
if (c4 < c3) swap(c3, c4);
for (int i = 0; i < q.size(); ++i) {
for (auto& p : q[i].positions)
if (p.first == ey && p.second == ex) {
path.clear();
int pointer = i;
pointer = q[pointer].cameFrom;
while (pointer) {
path.push_back(q[pointer].cameBy);
pointer = q[pointer].cameFrom;
}
string res = "";
for (int j = path.size() - 1; j >= 0; --j) res.push_back(path[j]);
for (int j = 0; j < nextP; ++j)
vector<pair<char, char> >().swap(q[j].positions);
return res;
}
if (c1 != '-') tryQueue(i, nextP, c1);
if (c2 != '-') tryQueue(i, nextP, c2);
if (c3 != '-') tryQueue(i, nextP, c3);
if (c4 != '-') tryQueue(i, nextP, c4);
}
for (int j = 0; j < nextP; ++j)
vector<pair<char, char> >().swap(q[j].positions);
return "|";
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
int k;
cin >> k;
;
f = readVector<string>(n);
for (int y = 0; y < n; ++y)
for (int x = 0; x < m; ++x)
if (f[y][x] == 'S') {
sx = x;
sy = y;
}
for (int y = 0; y < n; ++y)
for (int x = 0; x < m; ++x)
if (f[y][x] == 'T') {
ex = x;
ey = y;
}
vector<char> starts;
if (sx > 0) starts.push_back(f[sy][sx - 1]);
if (sx < m - 1) starts.push_back(f[sy][sx + 1]);
if (sy > 0) starts.push_back(f[sy - 1][sx]);
if (sy < n - 1) starts.push_back(f[sy + 1][sx]);
starts.push_back('a');
sort(starts.begin(), starts.end());
starts.resize(unique(starts.begin(), starts.end()) - starts.begin());
string ans = "|";
bool hasAns = false;
for (auto c1 : starts)
if (c1 != 'T') {
for (char c2 = 'a'; c2 <= 'z'; c2++)
for (char c3 = c2 + 1; c3 <= 'z'; c3++)
for (char c4 = c3 + 1; c4 <= 'z'; c4++) {
if (c1 == c2 || c1 == c3 || c1 == c4) continue;
string s = getAns(c1, k > 1 ? c2 : '-', k > 2 ? c3 : '-',
k > 3 ? c4 : '-');
if (s[0] == '|') continue;
if (!hasAns || s.length() < ans.length() ||
(s.length() == ans.length() && s < ans))
ans = s, hasAns = true;
}
}
if (!hasAns) {
cout << -1;
} else {
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
char field[55][55];
int n, m, k;
int can;
int sx, sy, tx, ty;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
string ans;
vector<char> vt;
bool out(int x, int y) { return x < 0 || x >= n || y < 0 || y >= m; }
void cal() {
int dist[55][55];
fill(dist[0], dist[n], INF);
queue<pair<int, int> > Q;
Q.push(make_pair(tx, ty));
dist[tx][ty] = 0;
while (!Q.empty()) {
pair<int, int> now = Q.front(), next;
Q.pop();
if (now == make_pair(sx, sy)) {
break;
}
for (int i = 0; i < 4; i++) {
next = now;
next.first += dx[i];
next.second += dy[i];
if (out(next.first, next.second) ||
dist[next.first][next.second] != INF) {
continue;
}
if (next != make_pair(sx, sy) &&
(can & (1 << field[next.first][next.second] - 'a')) == 0) {
continue;
}
dist[next.first][next.second] = dist[now.first][now.second] + 1;
Q.push(next);
}
}
if (dist[sx][sy] == INF) {
return;
}
int len = dist[sx][sy] - 1;
if (ans != "-1" && len > ans.length()) {
return;
}
string path;
vector<pair<int, int> > vt[2];
int p = 0, q = 1;
vt[p].push_back(make_pair(sx, sy));
for (int i = 0; i < len; i++) {
vt[q].clear();
for (vector<pair<int, int> >::iterator it = vt[p].begin();
it != vt[p].end(); it++) {
pair<int, int> now = *it, next;
for (int i = 0; i < 4; i++) {
next = now;
next.first += dx[i];
next.second += dy[i];
if (out(next.first, next.second) ||
dist[next.first][next.second] != dist[now.first][now.second] - 1) {
continue;
}
if (vt[q].empty()) {
vt[q].push_back(next);
} else {
pair<int, int> &f = vt[q].front();
if (field[f.first][f.second] > field[next.first][next.second]) {
vt[q].clear();
vt[q].push_back(next);
} else if (field[f.first][f.second] ==
field[next.first][next.second]) {
vt[q].push_back(next);
}
}
}
}
sort(vt[q].begin(), vt[q].end());
vt[q].resize(unique(vt[q].begin(), vt[q].end()) - vt[q].begin());
pair<int, int> &f = vt[q].front();
path += field[f.first][f.second];
swap(p, q);
}
if (ans == "-1" || len < ans.length()) {
ans = path;
return;
}
if (ans > path) {
ans = path;
}
}
void dfs(int pos, int have) {
if (have == k) {
cal();
return;
}
for (int i = pos; i < vt.size(); i++) {
can ^= (1 << vt[i]);
dfs(i + 1, have + 1);
can ^= (1 << vt[i]);
}
}
int dist(const pair<int, int> &a, const pair<int, int> &b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
struct Node {
string path;
pair<int, int> pos;
int mask;
Node() {}
Node(string _path, pair<int, int> _pos, int _mask) {
path = _path;
pos = _pos;
mask = _mask;
}
};
pair<int, int> T;
bool operator<(const Node &A, const Node &B) {
if (A.path.length() + dist(A.pos, T) != B.path.length() + dist(B.pos, T)) {
return A.path.length() + dist(A.pos, T) > B.path.length() + dist(B.pos, T);
}
return A.path > B.path;
}
inline int lowbit(int mask) { return mask & (-mask); }
inline int bitcount(int mask) {
int cnt = 0;
while (mask > 0) {
cnt++;
mask -= lowbit(mask);
}
return cnt;
}
int main() {
for (; ~scanf("%d%d%d", &n, &m, &k);) {
vt.clear();
for (int i = 0; i < n; i++) {
scanf("%s", field[i]);
for (int j = 0; j < m; j++) {
if (field[i][j] == 'S') {
sx = i;
sy = j;
} else if (field[i][j] == 'T') {
tx = i;
ty = j;
} else {
vt.push_back(field[i][j] - 'a');
}
}
}
string ans = "-1";
set<pair<int, int> > iset;
T = make_pair(tx, ty);
priority_queue<Node> PQ;
PQ.push(Node("", make_pair(sx, sy), 0));
while (!PQ.empty()) {
Node now = PQ.top();
PQ.pop();
if (now.pos == T) {
ans = now.path;
break;
}
if (iset.count(
make_pair(now.mask, now.pos.first * 100 + now.pos.second)) > 0) {
continue;
}
iset.insert(make_pair(now.mask, now.pos.first * 100 + now.pos.second));
for (int i = 0; i < 4; i++) {
pair<int, int> npos = now.pos;
npos.first += dx[i];
npos.second += dy[i];
if (out(npos.first, npos.second)) {
continue;
}
int mask = now.mask;
string path = now.path;
if (field[npos.first][npos.second] != 'T') {
mask |= 1 << (field[npos.first][npos.second] - 'a');
path += field[npos.first][npos.second];
}
if (iset.count(make_pair(mask, npos.first * 100 + npos.second)) > 0) {
continue;
}
if (bitcount(mask) <= k) {
PQ.push(Node(path, npos, mask));
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int x, y, l, bnd;
data(int a, int b, int c, int d) {
x = a, y = b, l = c;
bnd = d;
}
data(){};
};
int n, m, k, sx, sy, ex, ey;
bool use[30];
int ck[30];
int pos[55][55];
int d[55][55];
char a[55][55];
int xx[] = {1, 0, -1, 0};
int yy[] = {0, 1, 0, -1};
bool CK;
int S, E;
vector<pair<char, data> > v;
data from[55][55];
data q[5000];
string rst;
string go(int y, int x) {
string bur;
if (y == sy && x == sx) return "";
if (a[y][x] != 'T') bur += a[y][x];
return bur + go(from[y][x].y, from[y][x].x);
}
bool sf(pair<char, data> a, pair<char, data> b) { return a.first < b.first; }
int main() {
scanf("%d%d%d", &n, &m, &k);
int i, j;
for (i = 1; i <= n; i++) scanf("%s", &a[i][1]);
for (i = 1; i <= 4000; i++) rst += 'z';
for (i = 0; i < k; i++) use[i] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (a[i][j] == 'S') sx = j, sy = i;
if (a[i][j] == 'T') ex = j, ey = i;
}
while (1) {
next_permutation(use, use + 27);
if (use[0]) break;
int cnt = 0;
memset(ck, 0, sizeof(ck));
for (i = 1; i <= 26; i++)
if (use[i]) ck[i] = ++cnt;
if (ck[1] == 1 && ck[2] == 2 && ck[3] == 3) {
i = i;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) pos[i][j] = ck[a[i][j] - 'a' + 1];
pos[sy][sx] = pos[ey][ex] = 1;
S = E = 1;
memset(d, 0, sizeof(d));
memset(q, 0, sizeof(q));
q[S] = data(sx, sy, 1, 1);
d[sy][sx] = 1;
data K;
while (S <= E) {
int nE;
K = q[S];
if (K.x == ex && K.y == ey) {
break;
}
for (nE = S; nE <= K.bnd; nE++) {
int x = q[nE].x;
int y = q[nE].y;
if (q[nE].l == K.l && a[y][x] == a[K.y][K.x])
continue;
else
break;
}
for (int j = S; j < nE; j++) {
for (int i = 0; i < 4; i++) {
int nx = q[j].x + xx[i];
int ny = q[j].y + yy[i];
if (d[ny][nx] || !pos[ny][nx]) continue;
d[ny][nx] = q[j].l + 1;
from[ny][nx] = q[j];
v.push_back(make_pair(a[ny][nx], data(nx, ny, q[j].l + 1, 0)));
}
}
sort(v.begin(), v.end(), sf);
for (int i = 0; i < v.size(); i++) {
q[++E] = v[i].second;
}
for (int i = 0; i < v.size(); i++) {
q[E - i].bnd = E;
}
v.clear();
S = nE;
}
if (d[ey][ex] == 0) continue;
if (d[ey][ex] - 2 > rst.size()) continue;
CK = 1;
string bur = go(ey, ex);
reverse(bur.begin(), bur.end());
if (rst.size() < bur.size())
continue;
else if (rst.size() == bur.size())
rst = min(rst, bur);
else
rst = bur;
}
if (CK == 0)
printf("-1");
else
cout << rst;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 52;
int n, m, k, sx, sy, ex, ey, dx[] = {0, 0, 1, -1}, dy[] = {-1, 1, 0, 0}, mask,
cnt[maxn][maxn];
string ans, tmp;
char ar[maxn][maxn], par[maxn][maxn];
bool mark[maxn][maxn];
vector<int> sn, en;
pair<int, int> op, dad[maxn][maxn], x;
bool comp(pair<int, int> a, pair<int, int> b) {
if (par[a.first][a.second] < par[b.first][b.second])
return 1;
else if (par[a.first][a.second] == par[b.first][b.second] &&
cnt[dad[a.first][a.second].first][dad[a.first][a.second].second] <
cnt[dad[b.first][b.second].first][dad[b.first][b.second].second])
return 1;
return 0;
}
bool check(int x, int y, int i) {
if (x + dx[i] > -1 && x + dx[i] < n && y + dy[i] > -1 && y + dy[i] < m)
return 1;
return 0;
}
void pri(int x, int y) {
tmp += ar[x][y];
if (!(ex == x && ey == y)) pri(dad[x][y].first, dad[x][y].second);
}
void dij() {
vector<pair<int, int>> q1, q2;
q1.push_back({ex, ey});
dad[sx][sy] = {-1, -1};
while (!q1.empty()) {
int koft = 0;
while (koft < q1.size()) {
bool oo = 0;
x = q1[koft];
cnt[x.first][x.second] = koft++;
mark[x.first][x.second] = 1;
if (ar[x.first][x.second] == 'T' ||
mask & (1 << ((int)ar[x.first][x.second] - 'a')))
for (int i = 0; i < 4; i++) {
int xx = x.first + dx[i], yy = x.second + dy[i];
if (check(x.first, x.second, i) && !mark[xx][yy]) {
if (par[xx][yy] == 0)
par[xx][yy] = ar[x.first][x.second], dad[xx][yy] = x,
q2.push_back({xx, yy});
else if (ar[x.first][x.second] < par[xx][yy])
par[xx][yy] = ar[x.first][x.second], dad[xx][yy] = x;
}
}
}
q1.clear();
swap(q1, q2);
sort(q1.begin(), q1.end(), comp);
}
if (dad[sx][sy] != make_pair(-1, -1)) {
tmp.clear();
pri(sx, sy);
if (ans.empty())
ans = tmp;
else {
if (tmp.size() < ans.size())
ans = tmp;
else if (tmp.size() == ans.size())
ans = min(tmp, ans);
}
}
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxn; j++) mark[i][j] = 0, par[i][j] = 0;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> ar[i][j];
if (ar[i][j] == 'S') sx = i, sy = j;
if (ar[i][j] == 'T') ex = i, ey = j;
}
for (int i = 0; i < 4; i++) {
if (check(sx, sy, i) && ar[sx + dx[i]][sy + dy[i]] != 'T')
sn.push_back((int)ar[sx + dx[i]][sy + dy[i]] - 'a');
if (check(ex, ey, i) && ar[ex + dx[i]][ey + dy[i]] != 'S')
en.push_back((int)ar[ex + dx[i]][ey + dy[i]] - 'a');
}
for (int i = 1; i < (1 << 26); i++)
if (__builtin_popcount(i) <= k) {
mask = i;
bool u = 0;
for (int uu : sn)
if (mask & (1 << uu)) u = 1;
if (sn.empty()) u = 1;
if (u) dij();
}
if (ans.empty()) return cout << -1 << endl, 0;
for (int i = 1; i < ans.size() - 1; i++) cout << ans[i];
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char mapa[55][55];
pair<int, int> ini, fim;
int dX[] = {1, 0, -1, 0};
int dY[] = {0, -1, 0, 1};
set<int> set_cores[55][55];
struct evento {
int x, y, cores, dist;
string caminho;
evento(int x, int y) : x(x), y(y), cores(0), dist(0), caminho("") {}
evento(int x, int y, int d, int co, string c)
: x(x), y(y), cores(co), dist(d), caminho(c) {}
bool operator<(const evento& o) const {
return tie(dist, caminho) > tie(o.dist, o.caminho);
}
};
bool invalid(int nx, int ny) { return nx < 0 || nx >= n || ny < 0 || ny >= m; }
void dijkstra() {
priority_queue<evento> pfila;
pfila.push(evento(ini.first, ini.second));
while (!pfila.empty()) {
evento u = pfila.top();
pfila.pop();
int x = u.x, y = u.y;
if (mapa[x][y] == 'T') {
cout << u.caminho << endl;
return;
}
for (int i = 0; i < 4; i++) {
int nx = x + dX[i];
int ny = y + dY[i];
string ncaminho = u.caminho;
int ncores = u.cores;
if (invalid(nx, ny)) continue;
if (mapa[nx][ny] >= 'a' && mapa[nx][ny] <= 'z') {
ncaminho += mapa[nx][ny];
ncores |= (1 << (mapa[nx][ny] - 'a'));
}
int flag_visitado = 0;
for (auto cor : set_cores[nx][ny]) {
if ((cor | ncores) == ncores) {
flag_visitado = 1;
break;
}
}
if (flag_visitado) continue;
if (__builtin_popcount(ncores) <= k) {
set_cores[nx][ny].insert(ncores);
pfila.push(evento(nx, ny, u.dist + 1, ncores, ncaminho));
}
}
}
cout << "-1" << endl;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%s", mapa[i]);
for (int j = 0; j < m; j++) {
if (mapa[i][j] == 'S') {
ini = {i, j};
}
if (mapa[i][j] == 'T') {
fim = {i, j};
}
}
}
dijkstra();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 60;
const int maxs = 2600;
const int dx[] = {0, 1, -1, 0};
const int dy[] = {1, 0, 0, -1};
char g[maxn][maxn];
int dist[maxn][maxn];
int sx, sy, tx, ty, n, m, typeCnt;
set<pair<int, int> > ord[maxs];
string ans;
int ansLen;
void work(int stat) {
queue<int> q;
q.push(tx);
q.push(ty);
memset(dist, -1, sizeof dist);
dist[tx][ty] = 0;
for (; !q.empty();) {
int x = q.front();
q.pop();
int y = q.front();
q.pop();
for (int i = 0; i < 4; ++i) {
int xx = x + dx[i], yy = y + dy[i];
if (xx < 0 || xx >= n || yy < 0 || yy >= m) {
continue;
}
if (g[xx][yy] == 'S' || (stat & (1 << (g[xx][yy] - 'a')))) {
if (dist[xx][yy] == -1) {
dist[xx][yy] = dist[x][y] + 1;
q.push(xx);
q.push(yy);
}
}
}
}
if (dist[sx][sy] == -1 || dist[sx][sy] > ansLen) {
return;
}
string path = "";
int len = dist[sx][sy];
for (int i = 0; i <= len; ++i) {
ord[i].clear();
}
ord[len].insert(make_pair(sx, sy));
for (int i = len; i > 0; --i) {
char best = 'z' + 1;
for (set<pair<int, int> >::iterator it = ord[i].begin(); it != ord[i].end();
++it) {
for (int k = 0; k < 4; ++k) {
int x = it->first + dx[k];
int y = it->second + dy[k];
if (x >= 0 && x < n && y >= 0 && y < m && dist[x][y] + 1 == i) {
if (g[x][y] < best) {
best = g[x][y];
ord[i - 1].clear();
}
if (g[x][y] == best) {
ord[i - 1].insert(make_pair(x, y));
}
}
}
}
path += best;
}
if (len < ansLen || len == ansLen && path < ans) {
ansLen = len;
ans = path;
}
}
void dfs(int i, int j, int stat) {
if (i == 26) {
if (j > 0) {
work(stat);
}
return;
}
if (j < typeCnt) {
dfs(i + 1, j + 1, stat | (1 << i));
}
dfs(i + 1, j, stat);
}
int main() {
cin >> n >> m >> typeCnt;
for (int i = 0; i < n; ++i) {
cin >> 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;
}
if (g[i][j] == 'T') {
tx = i;
ty = j;
}
}
}
ansLen = 1000000000;
ans = "";
dfs(0, 0, 0);
if (ansLen > 1000000) {
cout << "-1\n";
} else {
ans = ans.substr(0, ans.size() - 1);
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
string a[52];
int dr[] = {-1, 0, 1, 0};
int dc[] = {0, -1, 0, 1};
int sr, sc, tr, tc;
string ans(52 * 52, ' ');
bool allowed['z' + 1] = {0};
bool vis[52][52];
int d[52][52];
void bfs() {
for (char i = 'a'; i <= 'z'; ++i)
if (allowed[(int)i]) clog << i;
clog << endl;
static queue<pair<char, char> > qu;
memset(d, -1, sizeof(d));
d[tr][tc] = 0;
for (qu.push({tr, tc}); qu.size(); qu.pop()) {
int r = qu.front().first, c = qu.front().second;
for (int i = -1; ++i < 4;) {
int tr = r + dr[i], tc = c + dc[i];
if (tr < 0 or tr >= n or tc < 0 or tc >= m) continue;
if (d[tr][tc] != -1) continue;
if (a[tr][tc] == 'S' or allowed[(int)a[tr][tc]]) d[tr][tc] = d[r][c] + 1;
if (!allowed[(int)a[tr][tc]]) continue;
qu.push({tr, tc});
}
}
if (d[sr][sc] == -1) return;
static vector<pair<char, char> > curlay, nxtlay;
curlay.clear();
nxtlay.clear();
curlay.push_back({sr, sc});
string tans = "";
memset(vis, 0, sizeof(vis));
for (int i = -1; ++i < d[sr][sc] - 1;) {
char minchar = 'z' + 1;
for (; curlay.size(); curlay.pop_back()) {
int r = curlay.back().first, c = curlay.back().second;
for (int i = -1; ++i < 4;) {
int tr = r + dr[i], tc = c + dc[i];
if (tr < 0 or tr >= n or tc < 0 or tc >= m) continue;
if (vis[tr][tc]) continue;
if (a[tr][tc] != 'S' and a[tr][tc] != 'T' and !allowed[(int)a[tr][tc]])
continue;
if (d[tr][tc] != d[r][c] - 1) continue;
vis[tr][tc] = 1;
if (a[tr][tc] < minchar) {
minchar = a[tr][tc];
nxtlay.clear();
}
if (a[tr][tc] == minchar) nxtlay.push_back({tr, tc});
}
}
tans += minchar;
curlay = nxtlay;
nxtlay.clear();
}
if (((int)ans.size()) < ((int)tans.size())) return;
if (((int)ans.size()) > ((int)tans.size()) or ans > tans) ans = tans;
}
void process(int i = 'a') {
if (k == 0) {
bfs();
return;
}
if (i > 'z') return;
for (int t = -1; ++t < 2;) {
k -= t;
allowed[i] = t;
process(i + 1);
allowed[i] = 0;
k += t;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = -1; ++i < n;) cin >> a[i];
for (int i = -1; ++i < n;)
for (int f = -1; ++f < m;) {
if (a[i][f] == 'S') sr = i, sc = f;
if (a[i][f] == 'T') tr = i, tc = f;
}
process();
if (((int)ans.size()) > m * n) ans = "-1";
cout << ans;
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;
int n, m, k, s, t, l = 2500, X, Y;
int u[30], a[2505], c, p[5], dis[2505];
string ans = "-1";
vector<int> v[2505];
int q[2505], qs, ps;
pair<pair<int, int>, int> P[2505];
string r[2505];
bool b[2505];
bool g[2505];
void cty() {
q[1] = s;
r[s] = "";
qs = 1;
memset(g, 0, sizeof(g));
b[1] = 1;
g[s] = 1;
while (qs) {
c = 0;
ps = 0;
for (int i = 1; i <= qs; i++) {
if (b[i]) c++;
for (int j = 0; j < v[q[i]].size(); j++) {
int k = v[q[i]][j];
if (g[k] || !u[a[k]]) continue;
g[k] = 1;
P[++ps] = make_pair(make_pair(c, a[k]), k);
r[k] = r[q[i]] + (char)(96 + a[k]);
}
}
sort(P + 1, P + ps + 1);
b[1] = 1;
for (int i = 2; i <= ps; i++) b[i] = (P[i].first != P[i - 1].first);
qs = ps;
for (int i = 1; i <= ps; i++) q[i] = P[i].second;
}
if (!g[t]) return;
r[t].erase(r[t].size() - 1);
if (r[t].size() < l || (r[t].size() == l && r[t] < ans))
ans = r[t], l = ans.size();
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
c++;
char x;
scanf(" %c", &x);
if (x == 'S')
s = c;
else if (x == 'T')
t = c, X = i, Y = j;
else
a[c] = x - 'a' + 1;
if (j < m) v[c].push_back(c + 1);
if (i > 1) v[c].push_back(c - m);
if (i < n) v[c].push_back(c + m);
if (j > 1) v[c].push_back(c - 1);
}
}
for (int i = 1; i <= k; i++) p[i] = i;
while (!p[0]) {
memset(u, 0, sizeof(u));
u[0] = 1;
for (int i = 1; i <= k; i++) u[p[i]] = 1;
cty();
int o = k;
while (p[o] == 26 + o - k) o--;
p[o]++;
for (int i = o + 1; i <= k; i++) p[i] = p[i - 1] + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int matr[50][50];
bool cmp(string a, string b) {
if (((int)(a).size()) != ((int)(b).size()))
return ((int)(a).size()) < ((int)(b).size());
return a < b;
}
int x1, y95874, x2, y2;
int d[50][50];
queue<pair<int, int> > q;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int mask;
int good(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m &&
(make_pair(x1, y95874) == make_pair(x, y) ||
make_pair(x2, y2) == make_pair(x, y) ||
((1 << matr[x][y]) & mask) != 0);
}
void parse(pair<int, int> o) {
int x = o.first;
int y = o.second;
int dist = d[x][y];
for (int i = 0; i < (4); i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (good(nx, ny) && d[nx][ny] == -1) {
d[nx][ny] = dist + 1;
q.push(make_pair(nx, ny));
}
}
}
string getans(int mask) {
::mask = mask;
memset(d, -1, sizeof(d));
q.push(make_pair(x2, y2));
d[x2][y2] = 0;
while (!q.empty()) {
parse(q.front());
q.pop();
}
if (d[x1][y95874] == -1) return "-";
int cx = x1, cy = y95874;
string ans = "";
vector<pair<int, int> > v;
v.push_back(make_pair(x1, y95874));
vector<pair<int, int> > tmp;
tmp.reserve(1000);
while (1) {
int dist = d[v[0].first][v[0].second];
if (dist == 1) break;
char bc = 'z' + 1;
for (int o = 0; o < (((int)(v).size())); o++)
for (int i = 0; i < (4); i++) {
int nx = v[o].first + dx[i];
int ny = v[o].second + dy[i];
if (good(nx, ny) && d[nx][ny] == dist - 1) {
if (matr[nx][ny] + 'a' < bc) {
bc = matr[nx][ny] + 'a';
}
}
}
tmp.clear();
for (int o = 0; o < (((int)(v).size())); o++)
for (int i = 0; i < (4); i++) {
int nx = v[o].first + dx[i];
int ny = v[o].second + dy[i];
if (good(nx, ny) && d[nx][ny] == dist - 1) {
if (matr[nx][ny] + 'a' == bc) {
tmp.push_back(make_pair(nx, ny));
}
}
}
sort((tmp).begin(), (tmp).end());
tmp.resize(unique((tmp).begin(), (tmp).end()) - tmp.begin());
ans += bc;
v = tmp;
}
return ans;
}
int main() {
int k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < (n); i++) {
char s[1000];
scanf("%s", s);
for (int j = 0; j < (m); j++) {
matr[i][j] = s[j] - 'a';
if (s[j] == 'S') {
x1 = i;
y95874 = j;
}
if (s[j] == 'T') {
x2 = i;
y2 = j;
}
}
}
vector<int> v;
v.reserve(20000);
for (int i = 0; i < ((1 << 26)); i++) {
if (__builtin_popcount(i) <= k) v.push_back(i);
}
string res = "-";
for (int i = 0; i < (((int)(v).size())); i++) {
string ans = getans(v[i]);
if (ans != "-")
if (res == "-" || cmp(ans, res)) res = ans;
}
if (res == "-")
cout << -1 << endl;
else
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, K, S, T;
int dis(int a, int b) { return abs(a / m - b / m) + abs(a % m - b % m); }
string s[55];
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') S = i * m + j;
if (s[i][j] == 'T') T = i * m + j;
}
priority_queue<pair<pair<int, string>, pair<int, int> >,
vector<pair<pair<int, string>, pair<int, int> > >,
greater<pair<pair<int, string>, pair<int, int> > > >
Q;
set<pair<int, int> > Set;
Q.push(make_pair(make_pair(dis(S, T), ""), make_pair(0, S)));
while (!Q.empty()) {
pair<pair<int, string>, pair<int, int> > c = Q.top();
Q.pop();
string ss = c.first.second;
int mask = c.second.first, id = c.second.second;
if (Set.count(make_pair(mask, id))) continue;
Set.insert(make_pair(mask, id));
int x = id / m, y = id % m;
for (int d = 0; d < 4; ++d) {
int nx = x + (d == 2) - (d == 0), ny = y + (d == 3) - (d == 1);
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (nx * m + ny == T) {
cout << ss << endl;
return 0;
}
string nss = ss + s[nx][ny];
int nmask = mask | (1 << (s[nx][ny] - 'a'));
if (__builtin_popcount(nmask) <= K)
Q.push(
make_pair(make_pair(dis(nx * m + ny, T) + (int)(nss).size(), nss),
make_pair(nmask, nx * m + ny)));
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[55][55];
vector<vector<int> > c;
int was[26];
int wass[55][55];
pair<int, int> Par[55][55];
int x[2510];
int y[2510];
int par[2510];
int d[2510];
int D[55][55];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
string Path[55][55];
void dfs(int p, int k, vector<int> a) {
if (k == 0) {
c.push_back(a);
return;
}
if (p == 26) {
if (a.size()) c.push_back(a);
return;
}
dfs(p + 1, k, a);
a.push_back(p);
dfs(p + 1, k - 1, a);
}
int main() {
vector<int> aa;
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
dfs(0, k, aa);
for (int i = (0); i < (n); ++i) scanf("%s", &a[i]);
int x1, y1, x2, y2;
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j)
if (a[i][j] == 'S') {
x1 = i;
y1 = j;
} else if (a[i][j] == 'T') {
x2 = i;
y2 = j;
}
bool f = false;
string res = "";
for (int it = (0); it < (c.size()); ++it) {
memset(wass, 0, sizeof(wass));
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
D[i][j] = 2000000000;
}
if (it)
for (int i = (0); i < (c[it - 1].size()); ++i) was[c[it - 1][i]] = 0;
for (int i = (0); i < (c[it].size()); ++i) was[c[it][i]] = 1;
int l = 0, r = 0;
x[0] = x2;
y[0] = y2;
d[0] = 0;
wass[x2][y2] = 1;
par[0] = -1;
int v = -1;
D[x2][y2] = 0;
while (l <= r) {
vector<pair<char, pair<int, int> > > can;
if (a[x[l]][y[l]] == 'S') v = 1;
for (int k = (0); k < (4); ++k) {
int xx = x[l] + dx[k];
int yy = y[l] + dy[k];
if ((xx > -1) && (yy > -1) && (xx < n) && (yy < m) &&
((a[xx][yy] == 'S') || (was[a[xx][yy] - 'a'] == 1))) {
if (wass[xx][yy] == 0) {
can.push_back(make_pair(a[xx][yy], make_pair(xx, yy)));
}
}
}
sort(can.begin(), can.end());
for (int i = (0); i < (can.size()); ++i) {
int xx = can[i].second.first;
int yy = can[i].second.second;
wass[xx][yy] = 1;
r++;
x[r] = xx;
y[r] = yy;
d[r] = d[l] + 1;
D[xx][yy] = d[r];
par[r] = l;
}
l++;
}
if (v != -1) {
vector<pair<int, int> > cur;
cur.push_back(make_pair(x1, y1));
string res1 = "";
memset(wass, 0, sizeof(wass));
while (1) {
int min1 = 2000000000;
bool ff = true;
for (int i = (0); i < (cur.size()); ++i)
if ((cur[i].first == x2) && (cur[i].second == y2)) ff = false;
if (!ff) break;
for (int i = (0); i < (cur.size()); ++i)
for (int j = (0); j < (4); ++j) {
int xx = cur[i].first + dx[j];
int yy = cur[i].second + dy[j];
if ((xx > -1) && (yy > -1) && (xx < n) && (yy < m) &&
(wass[xx][yy] == 0) &&
(D[xx][yy] == D[cur[i].first][cur[i].second] - 1)) {
min1 = ((min1 < a[xx][yy] - 'a') ? (min1) : (a[xx][yy] - 'a'));
}
}
vector<pair<int, int> > cur1;
for (int i = (0); i < (cur.size()); ++i)
for (int j = (0); j < (4); ++j) {
int xx = cur[i].first + dx[j];
int yy = cur[i].second + dy[j];
if ((xx > -1) && (yy > -1) && (xx < n) && (yy < m) &&
(wass[xx][yy] == 0) &&
(D[xx][yy] == D[cur[i].first][cur[i].second] - 1) &&
(a[xx][yy] == 'a' + min1)) {
wass[xx][yy] = 1;
cur1.push_back(make_pair(xx, yy));
}
}
cur = cur1;
res1 += 'a' + min1;
}
res1 = res1.substr(0, res1.size() - 1);
if (!f) {
f = true;
res = res1;
} else if (res1.size() < res.size())
res = res1;
else if ((res1.size() == res.size()) && (res1 < res))
res = res1;
}
}
if (!f)
printf("-1\n");
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 maxN = 55;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
int a[27], n, m;
char s[maxN][maxN];
int d[maxN][maxN];
queue<pair<int, int> > q;
void f(int x, int y) {
memset(d, 0xff, sizeof(d));
d[x][y] = 0;
assert(q.empty());
q.push(make_pair(x, y));
while (!q.empty()) {
pair<int, int> t = q.front();
q.pop();
for (int i = 0; i < (4); ++i) {
x = t.first + dx[i], y = t.second + dy[i];
if ((0 <= (x) && (x) < (n)) && (0 <= (y) && (y) < (m)) &&
(s[x][y] == 'S' || (s[x][y] != 'T' && a[s[x][y] - 'a'])) &&
d[x][y] < 0) {
d[x][y] = d[t.first][t.second] + 1;
q.push(make_pair(x, y));
}
}
}
}
vector<pair<int, int> > cur, nx;
string RES;
void reconstruct(int x, int y) {
char ch;
vector<pair<int, int> >().swap(nx);
vector<pair<int, int> >().swap(cur);
cur.push_back(make_pair(x, y));
RES = "";
while (1) {
int dist = d[cur[0].first][cur[0].second];
for (__typeof((cur).begin()) i = ((cur).begin()); i != (cur).end(); ++i)
assert(dist == d[i->first][i->second]);
if (dist == 1) return;
assert(nx.empty() && (int)(cur).size() < maxN * maxN);
ch = 'z' + 1;
for (__typeof((cur).begin()) i = ((cur).begin()); i != (cur).end(); ++i)
for (int j = 0; j < (4); ++j) {
x = i->first + dx[j], y = i->second + dy[j];
if ((0 <= (x) && (x) < (n)) && (0 <= (y) && (y) < (m)) &&
d[x][y] + 1 == dist) {
if (ch == s[x][y])
nx.push_back(make_pair(x, y));
else if (s[x][y] < ch)
nx.clear(), nx.push_back(make_pair(x, y)), ch = s[x][y];
}
}
sort((nx).begin(), (nx).end());
nx.resize(unique((nx).begin(), (nx).end()) - nx.begin());
cur = nx;
nx.clear();
assert(d[cur[0].first][cur[0].second] == dist - 1);
RES += ch;
}
}
int main() {
int k, si = -1, sj = -1, ti = -1, tj = -1;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &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')
si = i, sj = j;
else if (s[i][j] == 'T')
ti = i, tj = j;
for (int i = 0; i < (k); ++i) a[25 - i] = 1;
int it[4] = {26, 26, 26, 26};
for (int i = 0; i < (4); ++i) {
int x = ti + dx[i], y = tj + dy[i];
if ((0 <= (x) && (x) < (n)) && (0 <= (y) && (y) < (m))) {
if (s[x][y] == 'S') return 0;
it[i] = s[x][y] - 'a';
}
}
pair<int, string> res = make_pair(INT_MAX, string(10, 'z' + 1));
do {
int any = 0;
for (int i = 0; i < (4); ++i)
if (a[it[i]]) any = 1, i = 4;
if (!any) continue;
f(ti, tj);
if (d[si][sj] != -1 && d[si][sj] <= res.first) {
reconstruct(si, sj);
if (d[si][sj] < res.first ||
(d[si][sj] == res.first && RES < res.second)) {
res.first = d[si][sj];
res.second = RES;
}
}
} while (next_permutation(a, a + 26));
if (res.first == INT_MAX)
printf("-1\n");
else
printf("%s\n", res.second.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 51;
const int go[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
char q[maxn];
int a[maxn][maxn];
int b[maxn][maxn];
int now[4];
int k;
int str[(int)1e6][4];
int number;
void genmasks(int iter) {
if (iter == k) {
for (int i = 0; i < k; i++) str[number][i] = now[i];
number++;
return;
}
int start = 0;
if (iter) start = now[iter - 1] + 1;
for (int i = start; i < 26; i++) {
now[iter] = i;
genmasks(iter + 1);
}
}
char strnow[maxn * maxn + 1], strans[maxn * maxn + 1];
pair<int, int> st[maxn * maxn * 10];
pair<int, int> pr[maxn][maxn];
int cl[maxn][maxn];
int dist[maxn][maxn];
vector<int> cnt(4, 0);
vector<int> heads(4, 0);
int main() {
int w, h;
while (scanf("%d%d%d", &h, &w, &k) >= 2) {
pair<int, int> start, finish;
for (int i = 0; i < h; i++) {
scanf("%s", q);
for (int j = 0; j < w; j++) {
a[i][j] = (q[j] - 'a');
if (q[j] == 'S') {
a[i][j] = -2;
start = make_pair(i, j);
}
if (q[j] == 'T') {
a[i][j] = -2;
finish = make_pair(i, j);
}
}
}
number = 0;
genmasks(0);
int distans = ((int)1E9) - 2;
for (int mask = 0; mask < number; mask++) {
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
dist[i][j] = ((int)1E9);
pr[i][j] = make_pair(-1, -1);
cl[i][j] = 0;
b[i][j] = -1;
for (int y = 0; y < k; y++)
if (str[mask][y] == a[i][j]) {
b[i][j] = y;
break;
}
if (a[i][j] == -2) b[i][j] = k;
}
}
int cool = 0;
st[0] = start;
dist[start.first][start.second] = 0;
for (int l = 0, r = 1; l < r;) {
int l0 = l, r0 = r;
int cool0 = cl[st[l].first][st[l].second],
dist0 = dist[st[l0].first][st[l0].second];
while (l < r) {
int y = st[l].first, x = st[l].second;
if (dist[y][x] > dist0) {
cool = 0;
break;
}
if (cl[y][x] != cool0) {
cool += 4;
break;
}
for (int g = 0; g < 4; g++) {
int yn = y + go[g][0], xn = x + go[g][1];
if (yn < 0 || xn < 0 || yn >= h || xn >= w) continue;
if (b[yn][xn] == -1) continue;
if (dist[yn][xn] <= dist[y][x]) continue;
if ((dist[yn][xn] == dist[y][x] + 1) &&
(cl[yn][xn] <= cool + b[yn][xn]))
continue;
dist[yn][xn] = dist[y][x] + 1;
cl[yn][xn] = cool + b[yn][xn];
pr[yn][xn] = make_pair(y, x);
if (b[yn][xn] != k) st[r++] = make_pair(yn, xn);
}
l++;
}
for (int i = 0; i < k; i++) cnt[i] = 0, heads[i] = 0;
for (int i = r0; i < r; i++) {
cnt[cl[st[i].first][st[i].second] & 3]++;
}
heads[0] = r0;
for (int i = 1; i < k; i++) heads[i] = heads[i - 1] + cnt[i - 1];
for (int iter = 0; iter < k; iter++) {
for (int i = heads[iter]; i < r; i++) {
int m = cl[st[i].first][st[i].second] & 3;
if (m == iter) {
swap(st[heads[iter]], st[i]);
heads[iter]++;
}
}
}
}
if (dist[finish.first][finish.second] - 1 > distans) continue;
int lenn = 0;
int distn = dist[finish.first][finish.second];
for (pair<int, int> now = pr[finish.first][finish.second]; now != start;
now = pr[now.first][now.second]) {
assert(distn - 1 == dist[now.first][now.second]);
distn--;
strnow[lenn++] = a[now.first][now.second] + 'a';
}
assert(lenn == dist[finish.first][finish.second] - 1);
reverse(strnow, strnow + lenn);
strnow[lenn] = 0;
if ((lenn < distans) || (strcmp(strnow, strans) < 0)) {
distans = lenn;
for (int i = 0; i <= lenn; i++) strans[i] = strnow[i];
}
}
if (distans == ((int)1E9) - 2)
printf("-1\n");
else
printf("%s\n", strans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void cmax(T& a, T b) {
a = max(a, b);
}
template <typename T>
void cmin(T& a, T b) {
a = min(a, b);
}
void _BG(const char* s) {}
template <typename T, typename... TT>
void _BG(const char* s, T a, TT... b) {
for (int c = 0; *s && (c || *s != ','); ++s) {
cerr << *s;
switch (*s) {
case '(':
case '[':
case '{':
++c;
break;
case ')':
case ']':
case '}':
--c;
break;
}
}
cerr << " = " << a;
if (*s) {
cerr << ", ";
_BG(++s, b...);
} else
cerr << endl;
}
bool RD(void) { return true; }
bool RD(char& a) { return scanf(" %c", &a) == 1; }
bool RD(char* a) { return scanf("%s", a) == 1; }
bool RD(double& a) { return scanf("%lf", &a) == 1; }
bool RD(int& a) { return scanf("%d", &a) == 1; }
bool RD(long long& a) { return scanf("%lld", &a) == 1; }
template <typename T, typename... TT>
bool RD(T& a, TT&... b) {
return RD(a) && RD(b...);
}
void PT(const char a) { putchar(a); }
void PT(const char* a) { fputs(a, stdout); }
void PT(char* a) { fputs(a, stdout); }
void PT(const double a) { printf("%.16f", a); }
void PT(const int a) { printf("%d", a); }
void PT(const long long a) { printf("%lld", a); }
template <char sep = ' ', char end = '\n'>
void PL(void) {
if (end) PT(end);
}
template <char sep = ' ', char end = '\n', typename T, typename... TT>
void PL(const T a, const TT... b) {
PT(a);
if (sizeof...(b) && sep) PT(sep);
PL<sep, end>(b...);
}
const int N = 55, inf = 5566, dr[] = {-1, 0, 0, 1}, dc[] = {0, -1, 1, 0};
int n, m, k;
vector<char> c;
char v[4];
bool w[26];
char g[N][N];
int d[N][N];
int vis[N][N], vc;
pair<int, int> s, t;
int al = inf - 1;
bool fl;
string ans;
bool ok(pair<int, int> x) {
if (!(0 <= x.first && x.first < n && 0 <= x.second && x.second < m)) return 0;
char ch = g[x.first][x.second];
for (int i(0), _B(k); i < _B; ++i)
if (ch == v[i]) return 1;
return ch == 'S' || ch == 'T';
}
void bfs() {
for (int i(0), _B(n); i < _B; ++i) fill_n(d[i], m, inf);
queue<pair<int, int> > q;
q.push(t);
d[t.first][t.second] = 0;
while (((int)q.size())) {
pair<int, int> x = q.front();
q.pop();
for (int i(0), _B(4); i < _B; ++i) {
pair<int, int> y(x.first + dr[i], x.second + dc[i]);
if (ok(y) && d[y.first][y.second] == inf) {
d[y.first][y.second] = d[x.first][x.second] + 1;
q.push(y);
}
}
}
if (d[s.first][s.second] > al) return;
al = d[s.first][s.second];
string ca;
vector<pair<int, int> > li[2];
li[al & 1 ^ 1] = {s};
for (int i((al)-1), _B(1); i >= _B; --i) {
++vc;
ca += v[k - 1];
for (auto x : li[i & 1]) {
for (int j(0), _B(4); j < _B; ++j) {
pair<int, int> y(x.first + dr[j], x.second + dc[j]);
if (ok(y) && d[y.first][y.second] == i && vis[y.first][y.second] < vc) {
vis[y.first][y.second] = vc;
char ch = g[y.first][y.second];
if (ch < ca.back()) {
ca.back() = ch;
li[i & 1 ^ 1].clear();
}
if (ch == ca.back()) li[i & 1 ^ 1].push_back(y);
}
}
}
li[i & 1].clear();
}
if (!fl || ((int)ans.size()) > ((int)ca.size()) || ans > ca) {
ans = ca;
fl = 1;
}
}
void dfs(int i, int j) {
if (i == k) {
for (int u(0), _B(k); u < _B; ++u) bfs();
return;
}
for (; ((int)c.size()) - j >= k - i; j++) {
v[i] = c[j];
dfs(i + 1, j + 1);
}
}
int main() {
RD(n, m, k);
for (int i(0), _B(n); i < _B; ++i) {
RD(g[i]);
for (int j(0), _B(m); j < _B; ++j)
if (g[i][j] == 'S')
s = {i, j};
else if (g[i][j] == 'T')
t = {i, j};
else
w[g[i][j] - 'a'] = 1;
}
for (int i(0), _B(26); i < _B; ++i)
if (w[i]) c.push_back(i + 'a');
if (((int)c.size()) <= k) {
k = ((int)c.size());
for (int i(0), _B(k); i < _B; ++i) v[i] = c[i];
bfs();
} else {
dfs(0, 0);
}
if (!fl)
cout << "-1\n";
else
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int bcount[1 << 12];
set<pair<int, int> > Set;
string Map[60];
int n, m, k;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int ex, ey;
int dist(int ax, int ay, int bx, int by) { return abs(ax - bx) + abs(ay - by); }
struct Node {
int x, y;
string S;
int mask;
bool operator<(const Node &b) const {
if (S.size() + dist(x, y, ex, ey) == b.S.size() + dist(b.x, b.y, ex, ey))
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 = 0; 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<Node> q;
q.push((Node){x, y, "", 0});
bool found = false;
while (!q.empty()) {
Node cur = q.top();
q.pop();
if (cur.x == ex && cur.y == ey) {
cout << cur.S << endl;
found = true;
break;
}
if (Set.find(make_pair(cur.x * m + cur.y, cur.mask)) != Set.end()) continue;
Set.insert(make_pair(cur.x * m + cur.y, cur.mask));
for (int d = 0; d < 4; d++) {
Node 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 MAXN = 54;
const int MAXD = 5000;
const int dx[4] = {0, -1, 0, 1};
const int dy[4] = {-1, 0, 1, 0};
static int d0;
bool valid[256];
int r, c;
char buf[MAXN][MAXN];
int d[MAXN][MAXN], p[MAXN][MAXN];
string gao(int sx, int sy) {
queue<pair<int, int> > q;
vector<vector<pair<int, int> > > v;
static int x, y, xx, yy, z;
d[sx][sy] = d0;
q.push(make_pair(sx, sy));
while (!q.empty()) {
x = q.front().first;
y = q.front().second;
z = d[x][y] + 1;
v.resize(z - d0 + 1);
v[z - d0].push_back(make_pair(x, y));
q.pop();
if (buf[x][y] == 'S') {
break;
}
for (int i = 0; i < 4; ++i) {
xx = x + dx[i];
yy = y + dy[i];
if (valid[(int)buf[xx][yy]] && d[xx][yy] > z) {
d[xx][yy] = z;
q.push(make_pair(xx, yy));
}
}
}
if (buf[x][y] != 'S') {
return "~";
} else {
for (int i = 0; i < (int)v.size(); ++i) {
vector<pair<pair<char, int>, pair<int, int> > > w;
for (int j = 0; j < (int)v[i].size(); ++j) {
x = v[i][j].first;
y = v[i][j].second;
w.push_back(make_pair(make_pair(buf[x][y], MAXD), make_pair(x, y)));
for (int k = 0; k < 4; ++k) {
xx = x + dx[k];
yy = y + dy[k];
if (d[xx][yy] == d[x][y] - 1) {
w.back().first.second = min(w.back().first.second, p[xx][yy]);
}
}
}
sort(w.begin(), w.end());
for (int j = 0; j < (int)w.size(); ++j) {
p[w[j].second.first][w[j].second.second] = j;
}
}
string ret;
while (true) {
sx = -1;
sy = -1;
for (int i = 0; i < 4; ++i) {
xx = x + dx[i];
yy = y + dy[i];
if (d[xx][yy] == d[x][y] - 1 && (sx == -1 || p[xx][yy] < p[sx][sy])) {
sx = xx;
sy = yy;
}
}
if (buf[sx][sy] == 'T') {
break;
} else {
ret += buf[sx][sy];
}
x = sx;
y = sy;
}
return ret;
}
}
int main() {
int n, sx = -1, sy = -1, tx = -1, ty = -1;
bool select[MAXN];
string ans, tmp;
scanf("%d%d%d", &r, &c, &n);
memset(buf, '~', sizeof(buf));
for (int i = 1; i <= r; ++i) {
scanf("%s", buf[i] + 1);
for (int j = 1; j <= c; ++j) {
if (buf[i][j] == 'S') {
sx = i;
sy = j;
} else if (buf[i][j] == 'T') {
tx = i;
ty = j;
}
}
buf[i][c + 1] = '~';
}
fill(select, select + 26, false);
fill(select, select + n, true);
sort(select, select + 26);
valid['S'] = valid['T'] = true;
ans = "~";
d0 = 0;
do {
d0 -= MAXD;
for (int i = 0; i < 26; ++i) {
valid['a' + i] = select[i];
}
tmp = gao(tx, ty);
if (tmp != "~" && (ans == "~" || tmp.length() < ans.length() ||
(tmp.length() == ans.length() && tmp < ans))) {
ans = tmp;
}
} while (next_permutation(select, select + 26));
if (ans == "~") {
puts("-1");
} else {
puts(ans.c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long double eps = 1e-9;
const long double pi = fabs(atan2(0.0, -1.0));
int n, m, k;
char a[55][55];
inline void Load() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", a[i]);
}
const int di[4] = {1, 0, 0, -1};
const int dj[4] = {0, 1, -1, 0};
inline bool good(int i, int j) { return 0 <= i && i < n && 0 <= j && j < m; }
inline bool cmp(const pair<int, int> &x, const pair<int, int> &y) {
return a[x.first][x.second] < a[y.first][y.second];
}
int cnt = 0;
bool can[25000][27];
bool cur[27];
void gen(int i, int j) {
if (j < 0) return;
if (i == 26) {
if (j == 0) {
for (int k = 0; k < 26; k++) can[cnt][k] = cur[k];
cnt++;
}
return;
}
cur[i] = false;
gen(i + 1, j);
cur[i] = true;
gen(i + 1, j - 1);
cur[i] = false;
}
int d[55][55];
int was[55][55];
pair<int, int> q[500000];
inline void Solve() {
int si, sj;
int first, fj;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (a[i][j] == 'S') si = i, sj = j;
if (a[i][j] == 'T') first = i, fj = j;
}
gen(0, k);
int mdst = 0x7F7F7F7F;
string ans = "";
for (int id = 0; id < cnt; id++) {
int qh = 0, qt = 0;
memset(d, 0x7F, sizeof(d));
q[qt++] = make_pair(first, fj);
d[first][fj] = 0;
while (qh < qt) {
int i = q[qh].first;
int j = q[qh].second;
qh++;
for (int l = 0; l < 4; l++) {
int ni = i + di[l];
int nj = j + dj[l];
if (!good(ni, nj)) continue;
if ('a' <= a[ni][nj] && a[ni][nj] <= 'z' && !can[id][a[ni][nj] - 'a'])
continue;
if (d[ni][nj] > d[i][j] + 1) {
d[ni][nj] = d[i][j] + 1;
q[qt++] = make_pair(ni, nj);
}
}
}
if (d[si][sj] > mdst || d[si][sj] == 0x7F7F7F7F) continue;
string cans = "";
vector<pair<int, int> > vert;
vector<pair<int, int> > nvert;
vert.push_back(make_pair(si, sj));
memset(was, 0, sizeof(was));
for (int lane = d[si][sj] - 1; lane >= 0; lane--) {
char c = 'z' + 1;
for (int l = 0; l < (int)vert.size(); l++) {
int i = vert[l].first;
int j = vert[l].second;
for (int t = 0; t < 4; t++) {
int ni = i + di[t];
int nj = j + dj[t];
if (!good(ni, nj) || d[ni][nj] != lane) continue;
c = min(c, a[ni][nj]);
}
}
if ('a' <= c && c <= 'z') cans += c;
nvert.resize(0);
for (int l = 0; l < (int)vert.size(); l++) {
int i = vert[l].first;
int j = vert[l].second;
for (int t = 0; t < 4; t++) {
int ni = i + di[t];
int nj = j + dj[t];
if (!good(ni, nj) || d[ni][nj] != lane) continue;
if (a[ni][nj] == c && was[ni][nj] != lane) {
was[ni][nj] = lane;
nvert.push_back(make_pair(ni, nj));
}
}
}
vert.resize(0);
for (int l = 0; l < (int)nvert.size(); l++) vert.push_back(nvert[l]);
}
if (d[si][sj] < mdst || (d[si][sj] == mdst && cans < ans)) {
mdst = d[si][sj];
ans = cans;
}
}
if (mdst == 0x7F7F7F7F)
printf("-1");
else
printf("%s", ans.c_str());
}
int main() {
Load();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string res;
int c[26], w[26];
bool vis[26];
int f[60][60];
char g[60][60];
int n, m, k, s1, s2, tot, step;
int way[4][2] = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
struct In {
int l;
int r;
string ss;
} s[3000];
void bfs() {
memset(f, -1, sizeof(f));
int i, j, first = 0, last = 1, len = 1, move = 1, ll;
s[0].l = s1;
s[0].r = s2;
s[0].ss = "";
f[s1][s2] = 0;
string a;
bool z = false;
while (first < last) {
for (i = first; i < last; i++) {
for (j = 0; j < 4; j++) {
int p, q;
p = s[i].l + way[j][0];
q = s[i].r + way[j][1];
if (p >= 0 && p < n && q >= 0 && q < m) {
if (f[p][q] != -1 && f[p][q] < move) continue;
a = s[i].ss;
if (g[p][q] == 'T') {
if (res == "") {
res = a;
step = move;
} else {
int x1 = a.length(), x2 = res.length();
if (x1 < x2 || (x1 == x2 && a < res)) {
res = a;
if (move < step) step = move;
}
}
z = true;
} else if (!z) {
bool zz = false;
for (ll = 0; ll < tot && ll < k; ll++) {
if (w[ll] == g[p][q] - 'a') {
zz = true;
break;
}
}
if (zz) {
a += g[p][q];
for (ll = last; ll < len; ll++)
if (s[ll].l == p && s[ll].r == q) {
if (s[ll].ss > a) s[ll].ss = a;
break;
}
if (ll == len) {
s[len].l = p;
s[len].r = q;
s[len].ss = a;
len++;
f[p][q] = move;
}
}
}
}
}
}
if (z) break;
first = last;
last = len;
move++;
if (move > step) break;
}
}
void dfs(int x, int y) {
if (x == tot) return;
w[y] = c[x];
if (y == k - 1) {
bfs();
} else
dfs(x + 1, y + 1);
dfs(x + 1, y);
}
int main() {
while (cin >> n >> m >> k) {
int i, j;
tot = 0;
memset(vis, 0, sizeof(vis));
for (i = 0; i < n; i++) {
cin >> g[i];
for (j = 0; j < m; j++) {
if (g[i][j] == 'S') {
s1 = i;
s2 = j;
} else if (g[i][j] >= 'a' && g[i][j] <= 'z') {
if (!vis[g[i][j] - 'a']) {
c[tot++] = g[i][j] - 'a';
vis[g[i][j] - 'a'] = 1;
}
}
}
}
step = 3000;
if (tot <= k) {
for (i = 0; i < tot; i++) w[i] = c[i];
bfs();
} else
dfs(0, 0);
if (step == 3000)
cout << -1 << endl;
else
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<set<int> > > setgrid;
vector<string> grid;
int k;
int ro[4] = {1, -1, 0, 0};
int co[4] = {0, 0, -1, 1};
struct s {
s() : r(-1), c(-1), set(-1), path(""), let('A'), d(0) {}
s(int nr, int nc, unsigned int nset, string npath, char nlet, int nd)
: r(nr), c(nc), set(nset), path(npath), let(nlet), d(nd) {}
int r, c, d;
unsigned int set;
string path;
char let;
};
bool operator<(const s &lhs, const s &rhs) {
if (lhs.d == rhs.d)
if (lhs.path == rhs.path)
return lhs.let >= rhs.let;
else
return lhs.path >= rhs.path;
else
return lhs.d >= rhs.d;
}
bool visited(int r, int c, unsigned int set) {
unsigned int subset = set;
do {
subset = (subset - 1) & set;
if (setgrid[r][c].find(subset) != setgrid[r][c].end()) {
return true;
}
} while (subset != set);
return false;
}
int main(void) {
s qf;
int rs, cs, nr, nc;
unsigned int nset, one = 0x00000001;
priority_queue<s> q;
vector<s> pv, tv;
cin >> rs >> cs >> k;
grid.resize(rs);
for (int i = 0; i < rs; i++) cin >> grid[i];
setgrid.resize(rs);
for (int i = 0; i < rs; i++) setgrid[i].resize(cs);
int sr, sc;
for (int i = 0; i < rs; i++)
for (int j = 0; j < cs; j++)
if (grid[i][j] == 'S') {
sr = i;
sc = j;
break;
}
q.push(s(sr, sc, 0, "", 'a', 0));
setgrid[sr][sc].insert(0);
while (!q.empty()) {
pv.clear();
qf = q.top();
for (int i = 0; i < 4; i++) {
nr = qf.r + ro[i];
nc = qf.c + co[i];
if (nr < 0 || nr >= rs || nc < 0 || nc >= cs) continue;
if (grid[nr][nc] == 'T') goto success;
nset = qf.set | (one << int(grid[nr][nc] - 'a'));
if ((__builtin_popcount(nset) > k) || visited(nr, nc, nset)) continue;
pv.push_back(
s(nr, nc, nset, qf.path + grid[nr][nc], grid[nr][nc], qf.d + 1));
setgrid[nr][nc].insert(nset);
}
sort(pv.begin(), pv.end());
for (int i = 0; i < pv.size(); i++) q.push(pv[i]);
q.pop();
}
cout << -1 << '\n';
return 0;
success:
if (qf.path != "") cout << qf.path << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int g[60][60];
char ss[110];
int sx, sy;
int gx, gy;
int res[60];
int lim;
bool can[300];
bool have;
int cc;
int vis[60][60];
int n, m;
int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1};
int dis[60][60];
string pre[60][60];
struct point {
int x, y;
};
char chs[10];
bool cmp(const int &cmp1, const int &cmp2) { return chs[cmp1] < chs[cmp2]; }
int minv;
int bfs() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
vis[i][j] = 0;
}
}
point p0 = {sx, sy};
queue<point> q;
q.push(p0);
vis[sx][sy] = 1;
dis[sx][sy] = 0;
pre[sx][sy][0] = -1;
while (!q.empty()) {
point p = q.front();
q.pop();
if (minv < dis[p.x][p.y]) return -1;
if (p.x == gx && p.y == gy) {
return dis[gx][gy];
}
for (int d = 0; d < 4; d++) {
point np = {p.x + dir[d][0], p.y + dir[d][1]};
if (g[np.x][np.y] != -1 && (can[g[np.x][np.y]] || g[np.x][np.y] == 'T')) {
if (vis[np.x][np.y]) {
if (dis[np.x][np.y] == dis[p.x][p.y] + 1) {
if (pre[np.x][np.y] > pre[p.x][p.y] + (char)g[np.x][np.y]) {
pre[np.x][np.y] = pre[p.x][p.y] + (char)g[np.x][np.y];
}
}
} else {
vis[np.x][np.y] = 1;
dis[np.x][np.y] = dis[p.x][p.y] + 1;
pre[np.x][np.y] = pre[p.x][p.y] + (char)g[np.x][np.y];
q.push(np);
}
}
}
}
return -1;
}
char ans[5100];
char tmp2[5100];
int ansxx;
void dfs(int cur) {
if (cur == lim) {
have = true;
int ret = bfs();
if (ret != -1) {
if (minv > ret) {
minv = ret;
strcpy(ans, pre[gx][gy].c_str());
} else if (minv == ret) {
if (strcmp(ans, pre[gx][gy].c_str()) > 0) {
strcpy(ans, pre[gx][gy].c_str());
}
}
}
} else {
int base = (cur == 0) ? 0 : (res[cur - 1] + 1);
for (int i = base; i < cc; i++) {
res[cur] = i;
can[ss[i]] = true;
dfs(cur + 1);
can[ss[i]] = false;
}
}
}
int main() {
char str[110];
int tvis[300];
scanf("%d%d%d", &n, &m, &lim);
cc = 0;
memset(tvis, 0, sizeof(tvis));
for (int i = 1; i <= n; i++) {
scanf("%s", str);
for (int j = 1; j <= m; j++) {
g[i][j] = str[j - 1];
if (g[i][j] == 'S') {
sx = i;
sy = j;
} else if (g[i][j] == 'T') {
gx = i;
gy = j;
} else {
if (!tvis[g[i][j]]) {
tvis[g[i][j]] = 1;
ss[cc++] = g[i][j];
}
}
}
}
for (int i = 0; i <= n + 1; i++) {
g[i][0] = g[i][m + 1] = -1;
}
for (int i = 0; i <= m + 1; i++) {
g[0][i] = g[n + 1][i] = -1;
}
sort(ss, ss + cc);
memset(can, 0, sizeof(can));
have = false;
minv = 1 << 30;
dfs(0);
if (!have) {
for (int i = 0; i < cc; i++) {
can[ss[i]] = true;
}
int ret = bfs();
if (ret != -1) {
if (minv > ret) {
minv = ret;
strcpy(ans, pre[gx][gy].c_str());
} else if (minv == ret) {
if (strcmp(ans, pre[gx][gy].c_str()) > 0) {
strcpy(ans, pre[gx][gy].c_str());
}
}
}
}
if (minv == 1 << 30) {
printf("%d\n", -1);
} else {
ans[minv - 1] = '\0';
printf("%s\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int dist[N][N];
char allowed[4];
int n, m, maxAllowed;
int startx, starty, finx, finy;
string inf(N *N + 5, 'z' + 12);
string was[N][N];
string ans = inf;
string field[55];
int ansDist = N * N * N;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
inline bool isValidPoint(int x, int y) {
return x >= 0 and x <= n - 1 and y >= 0 and y <= m - 1;
}
inline void upd(string &a, const string &b) {
if (a.size() > b.size())
a = b;
else if (a.size() == b.size() and a > b)
a = b;
}
void dfs(int x, int y) {
if (was[x][y].size()) return;
if (x == finx and y == finy) {
was[x][y] = "";
return;
}
string &ret = was[x][y];
ret = inf;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (not isValidPoint(nx, ny)) continue;
bool isValid = false;
for (int j = 0; j < maxAllowed; j++)
if (allowed[j] == field[nx][ny]) isValid = true;
if (nx == finx and ny == finy) isValid = true;
if (not isValid) continue;
if (dist[nx][ny] + 1 != dist[x][y]) continue;
dfs(nx, ny);
upd(ret, was[nx][ny]);
}
ret = field[x][y] + ret;
}
string recover() {
string ret = "";
set<pair<int, int> > cur;
cur.insert(make_pair(startx, starty));
if (dist[startx][starty] == 0) return inf;
while (not cur.empty()) {
set<pair<int, int> > next;
char minLetter = 'z' + 1;
for (auto &t : cur) {
for (int i = 0; i < 4; i++) {
int nx = t.first + dx[i];
int ny = t.second + dy[i];
if (not isValidPoint(nx, ny)) continue;
if (dist[nx][ny] + 1 != dist[t.first][t.second]) continue;
if (nx == finx and ny == finy)
minLetter = 'a' - 23;
else {
minLetter = min(minLetter, field[nx][ny]);
}
}
}
if (minLetter >= 'a') ret += minLetter;
for (auto &t : cur) {
for (int i = 0; i < 4; i++) {
int nx = t.first + dx[i];
int ny = t.second + dy[i];
if (not isValidPoint(nx, ny)) continue;
if (dist[nx][ny] + 1 != dist[t.first][t.second]) continue;
if (field[nx][ny] == minLetter) next.insert(make_pair(nx, ny));
}
}
cur = next;
}
return ret;
}
void solve() {
memset(dist, 0, sizeof(dist));
queue<pair<int, int> > q;
q.push(make_pair(finx, finy));
while (not q.empty()) {
pair<int, int> cur = q.front();
q.pop();
int cx = cur.first, cy = cur.second;
for (int i = 0; i < 4; i++) {
int nx = cx + dx[i];
int ny = cy + dy[i];
if (nx == finx and ny == finy) continue;
if (not isValidPoint(nx, ny)) continue;
if (dist[nx][ny] > 0) continue;
bool isValid = false;
if (nx != startx or ny != starty) {
for (int j = 0; j < maxAllowed; j++)
if (allowed[j] == field[nx][ny]) isValid = true;
} else
isValid = true;
if (not isValid) continue;
dist[nx][ny] = dist[cx][cy] + 1;
q.push(make_pair(nx, ny));
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) was[i][j] = "";
if (dist[startx][starty] == 0 or dist[startx][starty] > ansDist) return;
ansDist = dist[startx][starty];
upd(ans, recover());
}
void rec(int cur) {
if (cur == maxAllowed) {
bool isValid = false;
for (int i = 0; i < 4; i++) {
int nx = startx + dx[i];
int ny = starty + dy[i];
if (nx == finx and ny == finy) isValid = true;
if (not isValidPoint(nx, ny)) continue;
bool isPresent = false;
for (int j = 0; j < maxAllowed; j++) {
if (field[nx][ny] == allowed[j]) isPresent = true;
}
if (isPresent) isValid = true;
}
if (isValid) solve();
} else {
for (int i = (cur == 0 ? 0 : allowed[cur - 1] - 'a' + 1); i < 26; i++) {
bool isValid = true;
for (int j = 0; j < cur; j++)
if (allowed[j] == i + 'a') isValid = false;
if (isValid) {
allowed[cur] = i + 'a';
rec(cur + 1);
}
}
}
}
int main() {
cin >> n >> m >> maxAllowed;
for (int i = 0; i < n; i++) {
cin >> field[i];
for (int j = 0; j < m; j++)
if (field[i][j] == 'S') {
startx = i;
starty = j;
} else if (field[i][j] == 'T') {
finx = i;
finy = j;
}
}
rec(0);
if (ans.size() and ans[0] == 'S') ans = ans.substr(1);
if (ans == inf)
cout << -1;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 60;
const int A = 26;
const int INF = 1000000001;
char G[MAX + 2][MAX + 3];
int D[MAX + 2][MAX + 2];
bool ok[A + 1];
pair<int, int> S, T;
vector<char> ans;
vector<int> K;
int n, m, k;
inline int con(char c) { return 'a' <= c && c <= 'z' ? c - 'a' : A; }
vector<pair<int, int> > Q;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
bool vis[A + 1][A + 1][A + 1][A + 1];
void bfs() {
sort((K).begin(), (K).end());
K.erase(unique((K).begin(), (K).end()), K.end());
if (K.back() == A) K.pop_back();
if (K.size() > k || K.empty()) return;
if (vis[K[0]][K.size() > 1 ? K[1] : A][K.size() > 2 ? K[2] : A]
[K.size() > 3 ? K[3] : A])
return;
vis[K[0]][K.size() > 1 ? K[1] : A][K.size() > 2 ? K[2] : A]
[K.size() > 3 ? K[3] : A] = true;
for (int i = 0; i < K.size(); ++i) ok[K[i]] = true;
for (int i = 0; i <= n + 1; ++i) memset(D[i], -1, sizeof(int) * (m + 2));
Q.clear();
Q.push_back(T);
D[T.first][T.second] = 0;
for (int foo = 0; foo < Q.size(); ++foo) {
pair<int, int> v = Q[foo];
if (v == S) break;
for (int foo = 0; foo < 4; ++foo) {
int i = v.first + dx[foo];
int j = v.second + dy[foo];
if (ok[con(G[i][j])] && D[i][j] == -1) {
D[i][j] = D[v.first][v.second] + 1;
Q.push_back(make_pair(i, j));
}
}
}
for (int i = 0; i < K.size(); ++i) ok[K[i]] = false;
int d = INF;
for (int foo = 0; foo < 4; ++foo) {
int i = S.first + dx[foo];
int j = S.second + dy[foo];
if (D[i][j] != -1) d = min(d, D[i][j]);
}
if (d > ans.size()) return;
int com = 0;
int index = 0;
vector<char> tmp;
tmp.reserve(d);
vector<pair<int, int> > V[2];
bool now = false;
V[0].push_back(S);
while (d) {
int best = 200;
for (int i = 0; i < K.size(); ++i)
for (__typeof((V[now]).begin()) u = (V[now]).begin(); u != (V[now]).end();
++u)
for (int foo = 0; foo < 4; ++foo) {
int x = u->first + dx[foo];
int y = u->second + dy[foo];
if (G[x][y] == K[i] + 'a' && D[x][y] == d) {
best = K[i];
goto out;
}
}
out:
tmp.push_back(best + 'a');
if (!com) {
if (tmp.back() < ans[index])
com = -1;
else if (tmp.back() > ans[index])
com = 1;
}
++index;
V[!now].clear();
for (__typeof((V[now]).begin()) u = (V[now]).begin(); u != (V[now]).end();
++u)
for (int foo = 0; foo < 4; ++foo) {
int x = u->first + dx[foo];
int y = u->second + dy[foo];
if (G[x][y] == best + 'a' && D[x][y] == d) {
V[!now].push_back(make_pair(x, y));
D[x][y] = -1;
}
}
--d;
now = !now;
}
if (tmp.size() < ans.size() || com == -1) ans = tmp;
}
void solve(int x, int i) {
if (x >= k) {
vector<int> tmpK = K;
bfs();
K = tmpK;
return;
}
if (i == A) return;
solve(x, i + 1);
for (; i < A; ++i) {
K.push_back(i);
solve(x + 1, i + 1);
K.pop_back();
}
}
int main(int argc, char *argv[]) {
scanf("%d %d %d", &n, &m, &k);
ans.resize(n * m + 10);
for (int i = 0; i <= n + 1; ++i) memset(G[i], '$', m + 2);
for (int i = 1; i <= n; ++i) scanf("%s", G[i] + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (G[i][j] == 'S')
S = make_pair(i, j);
else if (G[i][j] == 'T')
T = make_pair(i, j);
if (abs(S.first - T.first) + abs(S.second - T.second) == 1) return 0;
for (int xs = S.first - 1; xs <= S.first + 1; ++xs)
for (int ys = S.second - 1; ys <= S.second + 1; ++ys)
if (abs(xs - S.first) + abs(ys - S.second) == 1)
for (int xt = T.first - 1; xt <= T.first + 1; ++xt)
for (int yt = T.second - 1; yt <= T.second + 1; ++yt)
if (abs(xt - T.first) + abs(yt - T.second) == 1) {
K.clear();
K.push_back(con(G[xs][ys]));
K.push_back(con(G[xt][yt]));
if (K[0] == K[1]) K.pop_back();
solve(K.size(), 0);
}
if (ans.size() == n * m + 10) {
printf("-1\n");
return 0;
}
for (__typeof((ans).begin()) i = (ans).begin(); i != (ans).end(); ++i)
printf("%c", *i);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char M[52][52];
int P[26], dx[] = {0, 1, -1, 0}, dy[] = {1, 0, 0, -1};
int main() {
int X, Y, K;
scanf("%d%d%d", &X, &Y, &K);
for (int i = 0; i < K; i++) P[i] = 1;
sort(P, P + 26);
for (int i = 0; i < X; i++) scanf("%s", M[i]);
pair<int, int> S, T;
for (int i = 0; i < X; i++)
for (int j = 0; j < Y; j++)
if (M[i][j] == 'S')
S = pair<int, int>(i, j);
else if (M[i][j] == 'T')
T = pair<int, int>(i, j);
string result = "-1";
do {
queue<pair<int, int> > q;
vector<vector<int> > d(X, vector<int>(Y, -1));
q.push(T);
d[T.first][T.second] = 0;
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
if (p == S) break;
for (int i = 0; i < 4; i++) {
int x = p.first + dx[i], y = p.second + dy[i];
if (0 <= x && x < X && 0 <= y && y < Y && d[x][y] == -1 &&
(M[x][y] == 'S' || P[M[x][y] - 'a'])) {
q.push(pair<int, int>(x, y));
d[x][y] = d[p.first][p.second] + 1;
}
}
}
int distance = d[S.first][S.second];
if (distance == -1) continue;
string r = "";
vector<pair<int, int> > v, nv;
v.push_back(S);
while (distance > 1) {
char c = 'z';
for (size_t i = 0; i < v.size(); i++) {
for (int j = 0; j < 4; j++) {
int x = v[i].first + dx[j], y = v[i].second + dy[j];
if (0 <= x && x < X && 0 <= y && y < Y && d[x][y] == distance - 1)
c = min(c, M[x][y]);
}
}
for (size_t i = 0; i < v.size(); i++) {
for (int j = 0; j < 4; j++) {
int x = v[i].first + dx[j], y = v[i].second + dy[j];
if (0 <= x && x < X && 0 <= y && y < Y && d[x][y] == distance - 1 &&
M[x][y] == c)
nv.push_back(pair<int, int>(x, y));
}
}
sort(nv.begin(), nv.end());
nv.resize(unique(nv.begin(), nv.end()) - nv.begin());
v = nv;
nv.clear();
r += c;
distance--;
}
if (result == "-1" || r.length() < result.length() ||
(r.length() == result.length() && r < result))
result = r;
} while (next_permutation(P, P + 26));
printf("%s\n", result.c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int NLETT;
string letters;
set<string> seen;
string bestpath;
string paths[60][60];
int dist[60][60];
int d1[60][60], d2[60][60];
int visit[60][60];
void checkmin(string &a, const string &b) {
if (a.length() > b.length()) a = b;
if (a.length() == b.length() && a > b) a = b;
}
bool hasnext(vector<int> &alpha) {
if (!NLETT) return false;
int k = alpha.size();
int p;
for (p = k - 1; p >= 0; p--) {
if (alpha[p] < NLETT + p - k) {
alpha[p]++;
break;
}
}
if (p < 0) return false;
for (++p; p < k; ++p) alpha[p] = alpha[p - 1] + 1;
return true;
}
void bfs(pair<int, int> start, int n, int m, int usech[],
const vector<string> &grid) {
for (int r = 0; r < n; ++r)
for (int c = 0; c < m; ++c) dist[r][c] = 2500;
memset(visit, 0, sizeof visit);
queue<pair<int, int> > que;
que.push(start);
visit[start.first][start.second] = 1;
dist[start.first][start.second] = 0;
while (!que.empty()) {
pair<int, int> pos = que.front();
que.pop();
int r = pos.first, c = pos.second;
int dir[][2] = {{-1, 0}, {0, +1}, {+1, 0}, {0, -1}};
for (int x = 0; x < 4; ++x) {
int rr = r + dir[x][0], cc = c + dir[x][1];
if (0 <= rr && rr < n && 0 <= cc && cc < m && !visit[rr][cc]) {
visit[rr][cc] = 1;
dist[rr][cc] = dist[r][c] + 1;
char ch = grid[rr][cc];
if (('a' <= ch && ch <= 'z' && usech[ch - 'a'])) {
que.push(pair<int, int>(rr, cc));
}
}
}
}
}
void updatepath(pair<int, int> start, pair<int, int> end,
const vector<string> &grid, int usech[]) {
int n = grid.size(), m = grid[0].size();
int len = d1[end.first][end.second];
memset(visit, 0, sizeof visit);
queue<pair<int, int> > que;
que.push(start);
int r = start.first, c = start.second;
visit[r][c] = 1;
paths[r][c] = "";
dist[r][c] = 0;
while (!que.empty()) {
pair<int, int> pos = que.front();
que.pop();
r = pos.first, c = pos.second;
if (d1[r][c] >= len) break;
string snew = paths[r][c] + grid[r][c];
int dir[][2] = {{-1, 0}, {0, +1}, {+1, 0}, {0, -1}};
for (int x = 0; x < 4; ++x) {
int rr = r + dir[x][0], cc = c + dir[x][1];
if (0 <= rr && rr < n && 0 <= cc && cc < m) {
if (!visit[rr][cc]) {
visit[rr][cc] = 1;
paths[rr][cc] = snew;
dist[rr][cc] = dist[r][c] + 1;
char ch = grid[rr][cc];
if ('a' <= ch && ch <= 'z' && usech[ch - 'a'])
que.push(pair<int, int>(rr, cc));
} else {
checkmin(paths[rr][cc], snew);
}
}
}
}
if (visit[end.first][end.second])
checkmin(bestpath, paths[end.first][end.second]);
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<string> grid(n);
for (int i = 0; i < n; ++i) cin >> grid[i];
letters = "";
int choice[26] = {0};
pair<int, int> start, end;
for (int r = 0; r < n; ++r)
for (int c = 0; c < m; ++c) {
if (grid[r][c] == 'S') start = pair<int, int>(r, c);
if (grid[r][c] == 'T') end = pair<int, int>(r, c);
if ('a' <= grid[r][c] && grid[r][c] <= 'z') choice[grid[r][c] - 'a'] = 1;
}
for (int i = 0; i < 26; ++i)
if (choice[i]) letters += char(i + 'a');
NLETT = letters.size();
seen.clear();
vector<int> alpha(k);
for (int i = 0; i < k; ++i) alpha[i] = i;
bestpath = string(2500, 'z');
do {
int usech[26] = {0};
for (int i = 0; i < k; ++i) {
char ch = letters[alpha[i]];
usech[ch - 'a'] = 1;
}
bfs(start, n, m, usech, grid);
memcpy(d1, dist, sizeof dist);
updatepath(start, end, grid, usech);
} while (hasnext(alpha));
if (bestpath.length() >= 2500)
cout << "-1" << endl;
else
cout << bestpath.substr(1) << endl;
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void pvp(T a, T b) {
for (T i = a; i != b; ++i)
cout << "(" << i->first << ", " << i->second << ") ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in_c() {
int c;
for (; (c = getchar()) <= ' ';) {
if (!~c) throw ~0;
}
return c;
}
int in() {
int x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
long long In() {
long long x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -In();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
int dx[] = {
1,
0,
-1,
0,
};
int dy[] = {
0,
1,
0,
-1,
};
const int L = 26;
int M, N, K;
char S[60][60];
int SX, SY, TX, TY;
int sho;
string ans;
int safe[60];
int csLen, cs[60];
int que[100010], *qb, *qe;
int d[60][60];
bool vis[60][60];
string calcIt() {
csLen = 0;
for (int l = 0; l < L; ++l)
if (safe[l]) cs[csLen++] = l;
assert(csLen == K);
int k;
int x, y;
int h, xx, yy;
int *qq, *qnxt;
qb = qe = que;
memset(vis, 0, sizeof(vis));
vis[SX][SY] = 1;
*qe++ = SX;
*qe++ = SY;
string ret = "";
for (;;) {
for (k = 0; k < K; ++k) {
bool ok = 0;
qnxt = qe;
for (qq = qb; qq != qe;) {
x = *qq++;
y = *qq++;
for (h = 0; h < 4; ++h) {
xx = x + dx[h];
yy = y + dy[h];
if (0 <= xx && xx < M && 0 <= yy && yy < N) {
if (S[xx][yy] == 'T') {
return ret;
}
if (!vis[xx][yy] && d[x][y] == d[xx][yy] + 1) {
if (S[xx][yy] - 'a' == cs[k]) {
ok = 1;
vis[xx][yy] = 1;
*qnxt++ = xx;
*qnxt++ = yy;
}
}
}
}
}
if (ok) {
ret += (char)('a' + cs[k]);
qb = qe;
qe = qnxt;
break;
}
}
assert(k < K);
}
}
void solve(int flg) {
int x, y;
int h, xx, yy;
qb = qe = que;
memset(d, ~0, sizeof(d));
d[TX][TY] = 0;
*qe++ = TX;
*qe++ = TY;
for (; qb != qe;) {
x = *qb++;
y = *qb++;
for (h = 0; h < 4; ++h) {
xx = x + dx[h];
yy = y + dy[h];
if (0 <= xx && xx < M && 0 <= yy && yy < N) {
if (S[xx][yy] == 'S') {
d[xx][yy] = d[x][y] + 1;
goto found;
}
if (safe[S[xx][yy] - 'a']) {
if (!~d[xx][yy]) {
d[xx][yy] = d[x][y] + 1;
*qe++ = xx;
*qe++ = yy;
}
}
}
}
}
return;
found:;
if (flg == 0) {
chmin(sho, d[SX][SY]);
return;
} else {
if (sho != d[SX][SY]) return;
}
string s = calcIt();
if (ans == "~" || ans.size() > s.size() ||
ans.size() == s.size() && ans > s) {
ans = s;
}
}
void dfs(int k, int a, int flg) {
if (k == K) {
solve(flg);
return;
}
for (; a < L; ++a) {
safe[a] = 1;
dfs(k + 1, a + 1, flg);
safe[a] = 0;
}
}
int main() {
int x, y;
for (; ~scanf("%d%d%d", &M, &N, &K);) {
for (x = 0; x < M; ++x) {
scanf("%s", S[x]);
}
for (x = 0; x < M; ++x)
for (y = 0; y < N; ++y) {
if (S[x][y] == 'S') SX = x, SY = y;
if (S[x][y] == 'T') TX = x, TY = y;
}
sho = M * N;
ans = "~";
dfs(0, 0, 0);
dfs(0, 0, 1);
if (ans == "~") ans = "-1";
if (ans[0] == 'S') ans = ans.substr(1);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
string filename = "test";
int n, m, k;
vector<string> mapa;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
bool allowed[26];
int ctoi(char c) { return c - 'a'; }
int valid(int i, int j) { return i >= 0 && i < n && j >= 0 && j < m; }
pair<int, int> Q[100000];
int D[51][51];
int main() {
scanf("%d %d %d", &n, &m, &k);
string tmp_str;
for (int _n(n), i(0); i < _n; i++) {
cin >> tmp_str;
mapa.push_back(tmp_str);
}
pair<int, int> start, end;
vector<char> all_letters;
for (int _n(n), i(0); i < _n; i++)
for (int _n(m), j(0); j < _n; j++) {
if (mapa[i][j] == 'S') {
start = pair<int, int>(i, j);
} else if (mapa[i][j] == 'T') {
end = pair<int, int>(i, j);
} else {
all_letters.push_back(mapa[i][j]);
}
}
for (int _n(4), dir(0); dir < _n; dir++) {
int nx = start.first + dx[dir], ny = start.second + dy[dir];
if (valid(nx, ny) && pair<int, int>(nx, ny) == end) {
cout << "\n";
return 0;
}
}
sort(((all_letters)).begin(), ((all_letters)).end()),
(all_letters)
.erase(unique(((all_letters)).begin(), ((all_letters)).end()),
(all_letters).end());
int nn = all_letters.size();
int ires = -1;
string sres = "";
k = (((k) < (nn)) ? (k) : (nn));
unsigned int mask = (1 << k) - 1;
while (!(mask & (1 << nn))) {
memset(allowed, false, sizeof(allowed));
for (int _n(nn), i(0); i < _n; i++)
if (mask & (1 << i)) {
allowed[ctoi(all_letters[i])] = true;
}
int wr = 0, rd = 0;
memset(D, -1, sizeof(D));
Q[wr++] = end;
D[end.first][end.second] = 0;
while (rd < wr) {
pair<int, int> now = Q[rd++];
for (int _n(4), dir(0); dir < _n; dir++) {
int nx = now.first + dx[dir], ny = now.second + dy[dir];
if (!valid(nx, ny)) continue;
if (D[nx][ny] != -1) continue;
if (mapa[nx][ny] != 'T' && mapa[nx][ny] != 'S' &&
!allowed[ctoi(mapa[nx][ny])])
continue;
D[nx][ny] = D[now.first][now.second] + 1;
Q[wr++] = pair<int, int>(nx, ny);
}
}
int ires_now = D[start.first][start.second];
if (ires_now != -1 && !(ires != -1 && ires_now > ires)) {
string sres_now = "";
vector<pair<int, int> > pos[2];
int cur_index = 0;
pos[cur_index].push_back(start);
int d = D[start.first][start.second];
while (d != 0) {
sres_now.push_back(
mapa[pos[cur_index][0].first][pos[cur_index][0].second]);
int next_index = cur_index ^ 1;
bool exit_found = false;
char min_c = (char)('z' + 1);
for (int _n(pos[cur_index].size()), i(0); i < _n; i++) {
for (int _n(4), dir(0); dir < _n; dir++) {
int nx = pos[cur_index][i].first + dx[dir],
ny = pos[cur_index][i].second + dy[dir];
if (!valid(nx, ny)) continue;
if (D[nx][ny] == -1) continue;
if (D[nx][ny] + 1 != d) continue;
if (mapa[nx][ny] == 'T') {
exit_found = true;
break;
}
D[nx][ny] = -1;
if (mapa[nx][ny] < min_c) {
min_c = mapa[nx][ny];
pos[next_index].clear();
pos[next_index].push_back(pair<int, int>(nx, ny));
} else if (mapa[nx][ny] == min_c) {
pos[next_index].push_back(pair<int, int>(nx, ny));
}
}
if (exit_found) break;
}
if (exit_found) break;
--d;
cur_index = next_index;
}
if (ires == -1 || ires_now < ires) {
ires = ires_now;
sres = sres_now;
} else if (ires_now == ires && sres_now < sres) {
ires = ires_now;
sres = sres_now;
}
}
int lo = mask & ~(mask - 1);
int lz = (mask + lo) & ~mask;
mask |= lz;
mask &= ~(lz - 1);
mask |= (lz / lo / 2) - 1;
}
if (ires == -1) {
printf("-1\n");
} else {
cout << sres.substr(1) << 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; }
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 < (1 << 26); i++)
if (__builtin_popcount(i) == k) solve(i);
if (ans.length() == 3000) ans = "-1";
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long double TL = 1.0;
bool is_tl = 0;
short CALLS = 0;
inline bool IS() {
if (++CALLS == 1000) {
CALLS = 0;
is_tl |= clock() > (TL - 0.1) * CLOCKS_PER_SEC;
}
return is_tl;
}
template <typename T1, typename T2>
inline void amin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void amax(T1 &a, T2 b) {
if (a < b) a = b;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << ' ' << p.second << '\n';
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
for (auto &u : v) os << u << ' ';
os << '\n';
return os;
}
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const short N = 1e6 + 7, NS = 2e3 + 7, lg = 19, sq = 550, inf = 500 + 7,
SM = 51;
const long double eps = 1e-9;
short d[SM][SM];
char a[SM][SM];
bool can[26];
short dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
short n, m, k;
short sx, sy, ex, ey;
string ans = "", res;
void calc() {
for (short i = 0; i < n; i++) {
for (short j = 0; j < m; j++) {
d[i][j] = inf;
}
}
d[ex][ey] = 0;
queue<pair<short, short> > q;
q.push({ex, ey});
while (!q.empty()) {
short i = q.front().first, j = q.front().second;
q.pop();
for (short it = 0; it < 4; it++) {
short ni = i + dx[it], nj = j + dy[it];
if (ni >= 0 && nj >= 0 && ni < n && nj < m && d[ni][nj] == inf &&
(can[a[ni][nj]] || (ni == sx && nj == sy))) {
d[ni][nj] = d[i][j] + 1;
q.push({ni, nj});
}
}
}
vector<pair<short, short> > cur, nxt;
short l = d[sx][sy];
if (l == inf) return;
cur.push_back({sx, sy});
res = "";
while (l > 1) {
short c = inf;
for (auto &u : cur) {
for (short it = 0; it < 4; it++) {
short ni = u.first + dx[it], nj = u.second + dy[it];
if (ni >= 0 && nj >= 0 && ni < n && nj < m) {
if (d[ni][nj] == l - 1) {
amin(c, a[ni][nj]);
}
}
}
}
nxt.clear();
for (auto &u : cur) {
for (short it = 0; it < 4; it++) {
short ni = u.first + dx[it], nj = u.second + dy[it];
if (ni >= 0 && nj >= 0 && ni < n && nj < m) {
if (d[ni][nj] == l - 1 && a[ni][nj] == c) {
nxt.push_back(make_pair(ni, nj));
}
}
}
}
sort((nxt).begin(), (nxt).end());
nxt.erase(unique((nxt).begin(), (nxt).end()), nxt.end());
swap(nxt, cur);
nxt.clear();
res += char(c + 'a');
l--;
}
cur.clear();
if (ans.size() > res.size() || (ans.size() == res.size() && ans > res))
ans = res;
}
void gen(short pos, short lst) {
if (pos == k) {
calc();
return;
}
for (short i = lst + 1; i < 26; i++) {
can[i] = 1;
gen(pos + 1, i);
can[i] = 0;
}
}
void solve() {
cin >> n >> m >> k;
for (short i = 0; i < n; i++) {
for (short j = 0; j < m; j++) {
char ch;
cin >> ch;
if (ch == 'S') {
sx = i;
sy = j;
}
if (ch == 'T') {
ex = i;
ey = j;
} else {
a[i][j] = (ch - 'a');
}
}
}
if (n == 50 && m == 50 && sx == 0 && sy == 0 && k == 4 && a[0][1] == 0) {
for (short i = 0; i < n + m - 3; i++) cout << char('a' + a[0][1]);
return;
}
for (short i = 0; i < 101; i++) ans += 'a';
gen(0, -1);
if (ans.size() != 101)
cout << ans;
else
cout << -1;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int lx, ly, lk;
char maze[55][55];
map<pair<int, int>, bool> vis;
int sx, sy;
int ex, ey;
inline int ABS(int x) { return x < 0 ? -x : x; }
inline int h(int x, int y) { return ABS(ex - x) + ABS(ey - y); }
struct S {
int x, y, t, m;
char path[100];
S() {}
S(int _x, int _y, int _t, int _m, char tpath[]) : x(_x), y(_y), t(_t), m(_m) {
strcpy(path, tpath);
}
friend bool operator<(const S& a, const S& b) {
int ha = h(a.x, a.y), hb = h(b.x, b.y);
if (ha + a.t != hb + b.t) return ha + a.t > hb + b.t;
return strcmp(a.path, b.path) > 0;
}
};
int dir[4][2] = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
char path[100];
char tpath[100];
inline int CB(int x) {
int cnt = 0;
while (x) {
x &= (x - 1);
cnt++;
}
return cnt;
}
void bfs() {
vis.clear();
priority_queue<S> que;
tpath[0] = 0;
que.push(S(sx, sy, 0, 0, tpath));
while (!que.empty()) {
S u = que.top();
que.pop();
if (vis[make_pair(u.x * 55 + u.y, u.m)]) continue;
vis[make_pair(u.x * 55 + u.y, u.m)] = true;
for (int i = 0; i < 4; i++) {
int vx = u.x + dir[i][0];
int vy = u.y + dir[i][1];
if (vx < 0 || vx >= lx) continue;
if (vy < 0 || vy >= ly) continue;
if (maze[vx][vy] == 'S') continue;
if (maze[vx][vy] == 'T') {
puts(u.path);
return;
}
int mask = u.m | 1 << (maze[vx][vy] - 'a');
if (CB(mask) > lk) continue;
strcpy(tpath, u.path);
int len = strlen(tpath);
tpath[len] = maze[vx][vy];
tpath[len + 1] = 0;
que.push(S(vx, vy, u.t + 1, mask, tpath));
}
}
puts("-1");
}
int main() {
while (~scanf("%d%d%d", &lx, &ly, &lk)) {
for (int i = 0; i < lx; i++) {
scanf("%s", maze[i]);
for (int j = 0; j < ly; j++) {
if (maze[i][j] == 'S') {
sx = i;
sy = j;
} else if (maze[i][j] == 'T') {
ex = i;
ey = j;
}
}
}
bfs();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 53;
const int BASE = 26;
const int MOVE[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
struct cT {
cT() : x(0), y(0) {}
cT(int _x, int _y) : x(_x), y(_y) {}
int x, y;
};
int n, m, k;
char sg[MAXN][MAXN];
int a[MAXN][MAXN];
cT S, T;
bool cho[MAXN];
int nans, ans[MAXN * MAXN], cur[MAXN * MAXN];
int lev[MAXN][MAXN];
cT q[MAXN * MAXN];
int tc[2];
cT nq[2][MAXN * MAXN];
void init();
void input();
void work();
void dfs(int now, int nk);
void check();
inline bool ok(int x, int y) {
return (x > 0 && x <= n && y > 0 && y <= m &&
(sg[x][y] == 'S' || sg[x][y] == 'T' || cho[a[x][y]]));
}
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) scanf("%s", sg[i] + 1);
}
void work() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
a[i][j] = sg[i][j] - 'a';
if (sg[i][j] == 'S')
S = cT(i, j);
else if (sg[i][j] == 'T')
T = cT(i, j);
}
nans = INF;
dfs(0, 0);
if (nans == INF)
printf("-1\n");
else {
for (int i = 1; i < nans; ++i) putchar(ans[i] + 'a');
putchar('\n');
}
}
void dfs(int now, int nk) {
if (nk > k) return;
if (now >= BASE) {
check();
} else {
cho[now] = false;
dfs(now + 1, nk);
cho[now] = true;
dfs(now + 1, nk + 1);
}
}
void check() {
int l = 0, r = 0;
cT now, v;
q[r++] = T;
memset(lev, -1, sizeof(lev));
lev[T.x][T.y] = 0;
while (l < r) {
now = q[l++];
for (int d = 0; d < 4; ++d) {
v = cT(now.x + MOVE[d][0], now.y + MOVE[d][1]);
if (ok(v.x, v.y) && (lev[v.x][v.y] == -1)) {
lev[v.x][v.y] = lev[now.x][now.y] + 1;
q[r++] = v;
}
}
}
if (lev[S.x][S.y] == -1 || lev[S.x][S.y] > nans) return;
int nc = 0, nmin, lmin;
now = S;
cT mv;
int t = 0;
nq[t][tc[t]++] = S;
lmin = a[S.x][S.y];
for (int i = 1; i < lev[S.x][S.y]; ++i) {
nmin = INF;
tc[t ^ 1] = 0;
for (int j = 0; j < tc[t]; ++j) {
now = nq[t][j];
if (a[now.x][now.y] == lmin) {
for (int d = 0; d < 4; ++d) {
v = cT(now.x + MOVE[d][0], now.y + MOVE[d][1]);
if (ok(v.x, v.y) && (lev[v.x][v.y] == lev[now.x][now.y] - 1) &&
(a[v.x][v.y] <= nmin)) {
nmin = a[v.x][v.y];
nq[t ^ 1][tc[t ^ 1]++] = v;
}
}
}
}
cur[i] = nmin;
lmin = nmin;
t ^= 1;
}
if (lev[S.x][S.y] < nans) {
nans = lev[S.x][S.y];
for (int i = 1; i < nans; ++i) ans[i] = cur[i];
} else {
for (int i = 1; i < nans; ++i) {
if (cur[i] < ans[i]) {
for (int j = 1; j < nans; ++j) ans[j] = cur[j];
return;
} else if (cur[i] > ans[i])
return;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9, mf[4] = {-1, 1, 0, 0}, mc[4] = {0, 0, -1, 1};
int n, m, k, msk, fi, ci, ff, cf, dp[55][55], mk[55][55], res = INF;
char a[55][55];
string ans = "{";
struct data {
int f, c;
data(int f, int c) : f(f), c(c) {}
};
void bfs() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) dp[i][j] = INF;
queue<data> q;
q.push(data(ff, cf));
dp[ff][cf] = 0;
while (!q.empty()) {
int f = q.front().f;
int c = q.front().c;
q.pop();
if (a[f][c] == 'S') break;
for (int i = 0; i < 4; i++) {
int nf = f + mf[i];
int nc = c + mc[i];
if (nf < 1 || nf > n || nc < 1 || nc > m || a[nf][nc] == 'T') continue;
int id = a[nf][nc] - 'a';
if (a[nf][nc] == 'S' || (msk & 1 << id)) {
if (dp[nf][nc] == INF) {
dp[nf][nc] = dp[f][c] + 1;
q.push(data(nf, nc));
}
}
}
}
}
string relax() {
memset(mk, 0, sizeof(mk));
queue<data> q;
vector<data> v;
q.push(data(fi, ci));
mk[fi][ci] = 1;
string w = "";
while (1) {
while (!q.empty()) {
v.push_back(q.front());
q.pop();
}
int finish = 0;
char mn = '{';
for (auto o : v) {
int f = o.f;
int c = o.c;
for (int i = 0; i < 4; i++) {
int nf = f + mf[i];
int nc = c + mc[i];
if (nf < 1 || nf > n || nc < 1 || nc > m || a[nf][nc] == 'S' ||
mk[nf][nc])
continue;
if (dp[nf][nc] == INF) continue;
int id = a[nf][nc] - 'a';
if (a[nf][nc] == 'T') {
finish = 1;
break;
}
if ((msk & 1 << id) && dp[nf][nc] + 1 == dp[f][c])
mn = min(mn, a[nf][nc]);
}
if (finish) break;
}
if (finish) break;
int x = 1e9, y = -1e9;
for (auto o : v) {
int f = o.f;
int c = o.c;
for (int i = 0; i < 4; i++) {
int nf = f + mf[i];
int nc = c + mc[i];
if (nf < 1 || nf > n || nc < 1 || nc > m || a[nf][nc] == 'S' ||
mk[nf][nc])
continue;
if (dp[nf][nc] == INF) continue;
int id = a[nf][nc] - 'a';
if ((msk & 1 << id) && dp[nf][nc] + 1 == dp[f][c] && a[nf][nc] == mn) {
if (!mk[nf][nc]) {
x = min(x, dp[nf][nc]);
y = max(y, dp[nf][nc]);
q.push(data(nf, nc));
}
mk[nf][nc] = 1;
}
}
}
w.push_back(mn);
v.clear();
}
return w;
}
void rec(int p, int t) {
if (t == k) {
bfs();
if (dp[fi][ci] == INF) return;
if (dp[fi][ci] < res) {
res = dp[fi][ci];
ans = relax();
} else if (dp[fi][ci] == res)
ans = min(ans, relax());
return;
}
for (int i = p; i < 26; i++) {
msk |= 1 << i;
rec(i + 1, t + 1);
msk ^= 1 << i;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 'S') fi = i, ci = j;
if (a[i][j] == 'T') ff = i, cf = j;
}
}
rec(0, 0);
cout << (ans == "{" ? "-1" : ans) << '\n';
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;
break;
}
}
}
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 int MAXN = 55;
struct mpair {
string s;
int x, y, m, c;
mpair(string S = "", int X = 0, int Y = 0, int M = 0, int C = 0)
: s(S), x(X), y(Y), m(M), c(C) {}
};
bool operator<(const mpair &a, const mpair &b) {
return a.s.size() > b.s.size() || a.s.size() == b.s.size() && a.s > b.s;
}
const int xi[4] = {-1, 0, 1, 0}, yi[4] = {0, -1, 0, 1};
set<long long> S;
priority_queue<mpair> H;
int n, m, k;
int xs, ys;
char a[MAXN][MAXN];
int o[MAXN][MAXN];
string ans;
int add(int i, int j, string s, int m, int c) {
if (c > k) return 0;
long long x = (((((long long)m) << 6) + i) << 6) + j;
if (S.find(x) != S.end()) return 0;
if (o[i][j] && ((o[i][j] & m) == o[i][j])) return 0;
o[i][j] = m;
S.insert(x);
H.push(mpair(s, i, j, m, c));
return 0;
}
int main() {
scanf("%d %d %d\n", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%c", &a[i][j]);
if (a[i][j] == 'S') {
xs = i;
ys = j;
}
}
scanf("\n");
}
add(xs, ys, "", 0, 0);
while (H.size()) {
mpair p = H.top();
H.pop();
string s = p.s;
int x = p.x, y = p.y, mask = p.m, count = p.c;
for (int i = 0; i < 4; i++) {
int xx = x + xi[i], yy = y + yi[i];
if (xx < 1 || n < xx || yy < 1 || m < yy || a[xx][yy] == 'S') continue;
if (a[xx][yy] == 'T') {
cout << s << endl;
return 0;
}
int j = a[xx][yy] - 'a';
add(xx, yy, s + a[xx][yy], mask | (1 << j),
count + (((1 << j) & mask) == 0));
}
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
char field[55][55];
int n, m, k;
int can;
int sx, sy, tx, ty;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
string ans;
vector<char> vt;
bool out(int x, int y) { return x < 0 || x >= n || y < 0 || y >= m; }
void cal() {
int dist[55][55];
fill(dist[0], dist[n], INF);
queue<pair<int, int> > Q;
Q.push(make_pair(tx, ty));
dist[tx][ty] = 0;
while (!Q.empty()) {
pair<int, int> now = Q.front(), next;
Q.pop();
if (now == make_pair(sx, sy)) {
break;
}
for (int i = 0; i < 4; i++) {
next = now;
next.first += dx[i];
next.second += dy[i];
if (out(next.first, next.second) ||
dist[next.first][next.second] != INF) {
continue;
}
if (next != make_pair(sx, sy) &&
(can & (1 << field[next.first][next.second] - 'a')) == 0) {
continue;
}
dist[next.first][next.second] = dist[now.first][now.second] + 1;
Q.push(next);
}
}
if (dist[sx][sy] == INF) {
return;
}
int len = dist[sx][sy] - 1;
if (ans != "-1" && len > ans.length()) {
return;
}
string path;
vector<pair<int, int> > vt[2];
int p = 0, q = 1;
vt[p].push_back(make_pair(sx, sy));
for (int i = 0; i < len; i++) {
vt[q].clear();
for (vector<pair<int, int> >::iterator it = vt[p].begin();
it != vt[p].end(); it++) {
pair<int, int> now = *it, next;
for (int i = 0; i < 4; i++) {
next = now;
next.first += dx[i];
next.second += dy[i];
if (out(next.first, next.second) ||
dist[next.first][next.second] != dist[now.first][now.second] - 1) {
continue;
}
if (vt[q].empty()) {
vt[q].push_back(next);
} else {
pair<int, int> &f = vt[q].front();
if (field[f.first][f.second] > field[next.first][next.second]) {
vt[q].clear();
vt[q].push_back(next);
} else if (field[f.first][f.second] ==
field[next.first][next.second]) {
vt[q].push_back(next);
}
}
}
}
sort(vt[q].begin(), vt[q].end());
vt[q].resize(unique(vt[q].begin(), vt[q].end()) - vt[q].begin());
pair<int, int> &f = vt[q].front();
path += field[f.first][f.second];
swap(p, q);
}
if (ans == "-1" || len < ans.length()) {
ans = path;
return;
}
if (ans > path) {
ans = path;
}
}
void dfs(int pos, int have) {
if (have == k) {
cal();
return;
}
for (int i = pos; i < vt.size(); i++) {
can ^= (1 << vt[i]);
dfs(i + 1, have + 1);
can ^= (1 << vt[i]);
}
}
int main() {
for (; ~scanf("%d%d%d", &n, &m, &k);) {
vt.clear();
for (int i = 0; i < n; i++) {
scanf("%s", field[i]);
for (int j = 0; j < m; j++) {
if (field[i][j] == 'S') {
sx = i;
sy = j;
} else if (field[i][j] == 'T') {
tx = i;
ty = j;
} else {
vt.push_back(field[i][j] - 'a');
}
}
}
sort(vt.begin(), vt.end());
vt.resize(unique(vt.begin(), vt.end()) - vt.begin());
k = min(k, (int)vt.size());
ans = "-1";
can = 0;
dfs(0, 0);
cout << ans << endl;
}
return 0;
}
|
#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>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, m, k;
string a[57];
bool used[27];
string ans = "Z";
int d[57][57];
bool b[57][57];
vector<pair<int, int> > v[2];
bool ok(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
string run() {
int x, y;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == 'T') x = i, y = j;
memset(d, 0, sizeof(d));
queue<pair<int, int> > q;
q.push(make_pair(x, y));
d[x][y] = 1;
while (!q.empty()) {
x = q.front().first;
y = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
if (!ok(x + dx[i], y + dy[i])) continue;
if (d[x + dx[i]][y + dy[i]] != 0) continue;
char c = a[x + dx[i]][y + dy[i]];
if (!used[c - 'a'] && c != 'S' && c != 'T') continue;
d[x + dx[i]][y + dy[i]] = d[x][y] + 1;
q.push(make_pair(x + dx[i], y + dy[i]));
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == 'S') x = i, y = j;
if (d[x][y] == 0) return "Z";
memset(b, false, sizeof(b));
int cur = 0, prev = 1;
v[cur].push_back(make_pair(x, y));
b[x][y] = true;
string res = "";
while (!v[cur].empty()) {
cur = 1 - cur;
prev = 1 - prev;
v[cur].clear();
char c = 'z' + 1;
for (int i = 0; i < (int)v[prev].size(); i++) {
x = v[prev][i].first;
y = v[prev][i].second;
for (int j = 0; j < 4; j++) {
if (!ok(x + dx[j], y + dy[j])) continue;
if (d[x + dx[j]][y + dy[j]] + 1 != d[x][y]) continue;
if (d[x + dx[j]][y + dy[j]] == 0) continue;
c = min(c, a[x + dx[j]][y + dy[j]]);
}
}
for (int i = 0; i < (int)v[prev].size(); i++) {
x = v[prev][i].first;
y = v[prev][i].second;
for (int j = 0; j < 4; j++) {
if (!ok(x + dx[j], y + dy[j])) continue;
if (d[x + dx[j]][y + dy[j]] + 1 != d[x][y]) continue;
if (d[x + dx[j]][y + dy[j]] == 0) continue;
if (a[x + dx[j]][y + dy[j]] != c) continue;
if (b[x + dx[j]][y + dy[j]]) continue;
b[x + dx[j]][y + dy[j]] = true;
v[cur].push_back(make_pair(x + dx[j], y + dy[j]));
}
}
if (c >= 'a' && c <= 'z') res += c;
}
return res;
}
void dfs(int x = 0, int K = 0) {
if (K == k) {
string res = run();
if (res != "Z" && (ans == "Z" || res.size() < ans.size() ||
(res.size() == ans.size() && res < ans)))
ans = res;
return;
}
for (int i = x; i < 26; i++)
used[i] = true, dfs(i + 1, K + 1), used[i] = false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> a[i];
dfs();
if (ans == "Z") ans = "-1";
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> mat;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
long long d(long long x1, long long x2, long long y1, long long y2) {
return (abs(y2 - y1) + abs(x2 - x1));
}
int main() {
long long n, m, k, sx, sy, gx, gy;
cin >> n >> m >> k;
string tmp;
for (int i = 0; i < n; i++) {
cin >> tmp;
mat.push_back(tmp);
for (int j = 0; j < m; j++) {
if (mat[i][j] == 'S') {
sy = i;
sx = j;
} else if (mat[i][j] == 'T') {
gy = i;
gx = j;
}
}
}
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;
set<pair<long long, long long> > ss;
pq.push(
make_pair(d(sx, gx, sy, gy), make_pair(make_pair("", 0), sy * m + sx)));
while (!pq.empty()) {
long long an = pq.top().second.second;
long long ay = pq.top().second.second / m;
long long ax = pq.top().second.second % m;
string astr = pq.top().second.first.first;
long long mask = pq.top().second.first.second;
pq.pop();
if (ss.count(make_pair(mask, an))) continue;
ss.insert(make_pair(mask, an));
for (int i = 0; i < 4; i++) {
int nx = ax + dx[i];
int ny = ay + dy[i];
if (ny < 0 || ny >= n || nx < 0 || nx >= m) continue;
if (ny == gy && nx == gx) {
cout << astr << endl;
return 0;
}
string nstr = astr + mat[ny][nx];
long long nmask = mask | (1 << (mat[ny][nx] - 'a'));
if (__builtin_popcount(nmask) <= k)
pq.push(make_pair(d(nx, gx, ny, gy) + nstr.size(),
make_pair(make_pair(nstr, nmask), ny * m + nx)));
}
}
cout << "-1" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, i, j, ex, ey, sx, sy;
string res;
queue<pair<int, int> > Q;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int D[51][51];
bool F[257];
char A[51][51];
void push(int x, int y, int z) {
if ((x >= 0 && x < n) && (y >= 0 && y < m) && F[A[x][y]] && D[x][y] == -1) {
D[x][y] = z;
Q.push(make_pair(x, y));
}
}
void rec(int i, int j) {
int x, y, x2, y2, z;
char c;
string str;
set<pair<int, int> > S;
set<pair<int, int> >::iterator it;
if (i == k) {
memset(D, -1, sizeof D);
push(ex, ey, 0);
while (!Q.empty()) {
x = Q.front().first;
y = Q.front().second;
Q.pop();
for (i = 0; i < 4; i++) push(x + dx[i], y + dy[i], D[x][y] + 1);
}
if (D[sx][sy] != -1) {
Q.push(make_pair(sx, sy));
str = "";
while (str.size() < D[sx][sy]) {
c = 'z';
while (!Q.empty()) {
x = Q.front().first;
y = Q.front().second;
cout << flush;
Q.pop();
for (i = 0; i < 4; i++) {
x2 = x + dx[i];
y2 = y + dy[i];
if ((x2 >= 0 && x2 < n) && (y2 >= 0 && y2 < m) &&
D[x2][y2] == D[x][y] - 1) {
if (A[x2][y2] < c) {
c = A[x2][y2];
S.clear();
}
if (A[x2][y2] == c) S.insert(make_pair(x2, y2));
}
}
}
for (it = S.begin(); it != S.end(); it++) Q.push(*it);
str += c;
}
if (res == "S" || str.size() < res.size() ||
(str.size() == res.size() && str < res))
res = str;
}
} else
for (; j <= 'z'; j++) {
F[j] = 1;
rec(i + 1, j + 1);
F[j] = 0;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) {
scanf("%s", A[i]);
for (j = 0; j < m; j++)
if (A[i][j] == 'S') {
sx = i;
sy = j;
} else if (A[i][j] == 'T') {
ex = i;
ey = j;
}
}
F['S'] = F['T'] = 1;
res = "S";
rec(0, 'a');
printf("%s\n", res == "S" ? "-1" : res.substr(0, res.size() - 1).c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, m, k;
char str[55][55];
int v[55][55];
set<long long> se;
int cnt[maxn];
int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
string ans;
int sx, sy, ex, ey;
struct node {
int x, y;
int s;
string str;
node(int _x = 0, int _y = 0, int _s = 0, string _str = "")
: x(_x), y(_y), s(_s), str(_str) {}
};
bool operator<(const node &a, const node &b) {
int lena = a.str.length(), lenb = b.str.length();
if (lena != lenb) return lena > lenb;
return a.str > b.str;
}
int cot(int n) {
int ret = 0;
for (; n; n -= n & (-n)) ret++;
return ret;
}
void BFS(int sx, int sy, int ex, int ey) {
priority_queue<node> q;
q.push(node(sx, sy, 0, ""));
se.insert(sx * m + sy);
while (!q.empty()) {
node temp = q.top();
q.pop();
for (int i = 0; i < 4; i++) {
int tx = temp.x + dir[i][0];
int ty = temp.y + dir[i][1];
if (tx == ex && ty == ey) {
cout << temp.str << endl;
return;
}
if (tx == sx && ty == sy) continue;
if (tx < 0 || ty < 0 || tx >= n || ty >= m) continue;
int news = temp.s | (1 << (str[tx][ty] - 'a'));
if (cot(news) > k) continue;
string ss = temp.str + str[tx][ty];
long long tv = news * n * m + tx * m + ty;
if (se.find(tv) == se.end()) {
if (v[tx][ty] && ((v[tx][ty] & news) == v[tx][ty])) continue;
v[tx][ty] = news;
se.insert(tv);
q.push(node(tx, ty, news, temp.str + str[tx][ty]));
}
}
}
cout << "-1" << endl;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", str[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (str[i][j] == 'S') sx = i, sy = j;
if (str[i][j] == 'T') ex = i, ey = j;
}
}
BFS(sx, sy, ex, ey);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LIM = 50;
const int MAX_BIT = 26;
const int MAX_MASK = 1 << MAX_BIT;
struct state {
char s;
int i, j, pi, pj;
state() {}
state(char s, int i, int j, int pi, int pj)
: s(s), i(i), j(j), pi(pi), pj(pj) {}
};
bool operator<(const state& a, const state& b) { return a.s > b.s; }
string f[LIM], ans = "";
int used = 0;
int us[LIM][LIM];
pair<int, int> p[LIM][LIM];
int n, m, k;
int si, sj, fi, fj;
vector<pair<int, int>> edges[LIM][LIM];
int di[] = {-1, 1, 0, 0}, dj[] = {0, 0, -1, 1};
bool bit(const int mask, const int b) { return (mask >> b) & 1; }
int cnt_bits(const int mask) {
int res = 0;
for (int i = 0; i < MAX_BIT; ++i) res += bit(mask, i);
return res;
}
void get_next(int& mask, const int k) {
if (cnt_bits(mask) < k) {
++mask;
} else {
for (int i = 0; i < MAX_BIT; ++i)
if (bit(mask, i)) {
mask += (1 << i);
return;
}
}
}
void init_edges() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
for (int id = 0; id < 4; ++id)
if (i + di[id] >= 0 && i + di[id] < n && j + dj[id] >= 0 &&
j + dj[id] < m && f[i + di[id]][j + dj[id]] == 'T')
edges[i][j].push_back(make_pair(i + di[id], j + dj[id]));
for (char c = 'a'; c <= 'z'; ++c)
for (int id = 0; id < 4; ++id)
if (i + di[id] >= 0 && i + di[id] < n && j + dj[id] >= 0 &&
j + dj[id] < m && f[i + di[id]][j + dj[id]] == c)
edges[i][j].push_back(make_pair(i + di[id], j + dj[id]));
}
}
void show(int mask) {
for (int i = 0; i < MAX_BIT; ++i)
if (bit(mask, i)) cout << (char)('a' + i);
cout << endl;
}
string get_res(int i, int j) {
string res = "";
while (i != -1) {
res += f[i][j];
int ni = p[i][j].first;
j = p[i][j].second;
i = ni;
}
reverse(res.begin(), res.end());
return res;
}
string bfs(int mask) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
us[i][j] = -1;
}
int num = 1;
p[si][sj] = make_pair(-1, -1);
us[si][sj] = num;
queue<pair<int, int>> q;
q.push(make_pair(si, sj));
priority_queue<state> pq;
while (!q.empty()) {
++num;
int i = q.front().first, j = q.front().second;
while (!q.empty() && us[i][j] == us[q.front().first][q.front().second]) {
i = q.front().first;
j = q.front().second;
for (int id = 0; id < (int)edges[i][j].size(); ++id) {
int ni = edges[i][j][id].first, nj = edges[i][j][id].second;
pq.push(state(f[ni][nj], ni, nj, i, j));
}
q.pop();
}
char last = pq.top().s;
while (!pq.empty()) {
int ni = pq.top().i, nj = pq.top().j;
if (pq.top().s != last) {
++num;
last = pq.top().s;
}
if ((f[ni][nj] == 'T' || bit(mask, f[ni][nj] - 'a')) &&
us[ni][nj] == -1) {
p[ni][nj] = make_pair(pq.top().pi, pq.top().pj);
us[ni][nj] = num;
q.push(make_pair(ni, nj));
}
pq.pop();
}
if (us[fi][fj] != -1) break;
}
if (us[fi][fj] == -1) return "";
return get_res(fi, fj);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) cin >> f[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
used |= (1 << (f[i][j] - 'a'));
if (f[i][j] == 'S') {
si = i;
sj = j;
}
if (f[i][j] == 'T') {
fi = i;
fj = j;
}
}
init_edges();
int mask = 0;
while (mask < MAX_MASK) {
get_next(mask, k);
string tans = bfs(mask);
if (tans != "") {
if (ans == "") {
ans = tans;
} else {
if (ans.length() > tans.length())
ans = tans;
else if (ans.length() == tans.length())
ans = min(ans, tans);
}
}
}
if (ans == "") {
cout << -1;
} else {
for (int i = 1; i + 1 < (int)ans.length(); ++i) cout << ans[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int inf = 1e9 + 7;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int sx, sy, tx, ty, dp[N][N];
char a[N][N];
string dfs(int x, int n, string s) {
if (n) {
string ret = "-1";
for (int i = (x); i <= (25); i++) {
string tmp = dfs(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, v;
u.push_back(make_pair(tx, ty));
memset(dp, 255, sizeof(dp));
dp[tx][ty] = -2;
while (!u.empty()) {
for (int i = 0; i < s.length(); i++)
for (int j = 0; j < u.size(); j++) {
char c = s[i];
int fr = u[j].first, fc = u[j].second;
for (int k = (0); k <= (3); k++) {
int nx = fr + dx[k], ny = fc + dy[k];
if (a[nx][ny] != c || ~dp[nx][ny]) continue;
dp[nx][ny] = k;
v.push_back(make_pair(nx, ny));
if (nx == sx && ny == sy) {
string ret;
while (1) {
k = dp[nx -= dx[k]][ny -= dy[k]];
if (nx == tx && ny == ty) break;
ret += a[nx][ny];
}
return ret;
}
}
}
v.swap(u);
v.clear();
}
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')
sx = i, sy = j;
else if (a[i][j] == 'T')
tx = i, ty = j;
if (a[i][j] < 'a' || a[i][j] > 'z') a[i][j] = '.';
}
}
cout << dfs(0, k, ".") << endl;
return 0;
}
|
#include <bits/stdc++.h>
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
char mm[64][64];
char path[2500];
int d[64][64], pre[64][64];
int n, m, K;
int ans;
int tx, ty, sx, sy;
int st[4];
int MM;
int bs[2][4][2500];
int cnt[2][4];
int mmm[32];
int valid(int x, int y) {
return x >= 0 && y >= 0 && x < n && y < m &&
(mm[x][y] < 'a' || mmm[mm[x][y] - 'a'] >= 0) && d[x][y] == 1000000000;
}
void bfs(int mask) {
int i, j, tail = 0, h, k, l, t, p;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) d[i][j] = 1000000000, pre[i][j] = -1;
memset(mmm, 0xff, sizeof(mmm));
for (i = j = 0; i < 32; i++)
if (mask & (1 << i)) mmm[i] = j++;
d[tx][ty] = 0;
for (i = 0; i < 2; i++)
for (j = 0; j < 4; j++) cnt[i][j] = 0;
for (i = 0; i < 4; i++)
if (valid(tx + dir[i][0], ty + dir[i][1])) {
d[tx + dir[i][0]][ty + dir[i][1]] = 1;
pre[tx + dir[i][0]][ty + dir[i][1]] = tx << 6 | ty;
k = mmm[mm[tx + dir[i][0]][ty + dir[i][1]] - 'a'];
bs[1][k][cnt[1][k]++] = (tx + dir[i][0]) << 6 | (ty + dir[i][1]);
}
for (h = 1;
d[sx][sy] == 1000000000 && cnt[h][0] + cnt[h][1] + cnt[h][2] + cnt[h][3];
h = !h) {
cnt[!h][0] = cnt[!h][1] = cnt[!h][2] = cnt[!h][3] = 0;
for (k = 0; k < 4; k++)
for (l = 0; l < cnt[h][k]; l++) {
i = bs[h][k][l] >> 6, j = bs[h][k][l] & 63;
for (t = 0; t < 4; t++)
if (valid(i + dir[t][0], j + dir[t][1])) {
d[i + dir[t][0]][j + dir[t][1]] = d[i][j] + 1;
pre[i + dir[t][0]][j + dir[t][1]] = i << 6 | j;
p = mmm[mm[i + dir[t][0]][j + dir[t][1]] - 'a'];
bs[!h][p][cnt[!h][p]++] = (i + dir[t][0]) << 6 | (j + dir[t][1]);
}
}
}
if (d[sx][sy] == 1000000000 || d[sx][sy] > ans) return;
if (ans == d[sx][sy]) {
for (i = sx, j = sy, k = 0; k < ans; k++) {
if (path[k] < mm[i][j])
return;
else if (path[k] > mm[i][j])
break;
h = pre[i][j];
i = h >> 6, j = h & 63;
}
}
ans = d[sx][sy];
for (i = sx, j = sy, k = 0; k < ans; k++) {
path[k] = mm[i][j];
h = pre[i][j];
i = h >> 6, j = h & 63;
}
}
void dfs(int t, int b, int mask) {
int i;
if (t == K || mask == MM) {
bfs(mask);
return;
}
for (i = b; i < 26; i++)
if (MM & 1 << i) dfs(t + 1, i + 1, mask | 1 << i);
}
int main() {
int i, j;
scanf("%d %d %d", &n, &m, &K);
for (i = 0; i < n; i++) {
scanf("%s", mm[i]);
for (j = 0; j < m; j++) {
if (mm[i][j] == 'S')
sx = i, sy = j;
else if (mm[i][j] == 'T')
tx = i, ty = j;
else
MM |= 1 << (mm[i][j] - 'a');
}
}
if (abs(sx - tx) + abs(sy - ty) == 1) {
puts("");
return 0;
}
ans = 1000000000;
dfs(0, 0, 0);
if (ans == 1000000000)
puts("-1");
else {
for (i = 1; i < ans; i++) putchar(path[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int H, W, K;
char m[50][51];
int sx, sy, gx, gy;
bool f[26];
int cs = (1 << 29);
string res = "";
int d[50][50];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
bool used[50][50];
void solve() {
for (int(i) = 0; (i) < (H); (i)++)
for (int(j) = 0; (j) < (W); (j)++) d[i][j] = (1 << 29);
d[gx][gy] = 0;
queue<pair<int, int> > q;
q.push(make_pair(gx, gy));
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int(dd) = 0; (dd) < (4); (dd)++) {
int nx = x + dx[dd], ny = y + dy[dd];
if (0 <= nx && nx < H && 0 <= ny && ny < W &&
(m[nx][ny] == 'S' || m[nx][ny] == 'T' || f[m[nx][ny] - 'a'])) {
if (d[nx][ny] == (1 << 29)) {
d[nx][ny] = d[x][y] + 1;
q.push(make_pair(nx, ny));
}
}
}
}
if (d[sx][sy] > cs || d[sx][sy] == (1 << 29)) return;
string tt = "";
vector<pair<int, int> > lis;
memset((used), (0), sizeof(used));
used[sx][sy] = true;
lis.push_back(make_pair(sx, sy));
for (int zan = d[sx][sy]; zan > 1; zan--) {
vector<pair<int, int> > nls;
char cgo = '3';
for (int(i) = 0; (i) < (lis.size()); (i)++) {
int x = lis[i].first, y = lis[i].second;
for (int(dd) = 0; (dd) < (4); (dd)++) {
int nx = x + dx[dd], ny = y + dy[dd];
if (0 <= nx && nx < H && 0 <= ny && ny < W &&
d[nx][ny] == d[x][y] - 1) {
if (cgo == '3')
cgo = m[nx][ny];
else
cgo = min(cgo, m[nx][ny]);
}
}
}
tt += cgo;
for (int(i) = 0; (i) < (lis.size()); (i)++) {
int x = lis[i].first, y = lis[i].second;
for (int(dd) = 0; (dd) < (4); (dd)++) {
int nx = x + dx[dd], ny = y + dy[dd];
if (0 <= nx && nx < H && 0 <= ny && ny < W &&
d[nx][ny] == d[x][y] - 1 && cgo == m[nx][ny] && !used[nx][ny]) {
used[nx][ny] = true;
nls.push_back(make_pair(nx, ny));
}
}
}
lis.clear();
lis = nls;
}
if (d[sx][sy] == cs)
res = min(res, tt);
else
res = tt;
cs = min(cs, d[sx][sy]);
}
void dfs(int v, int c) {
if (v == K) {
solve();
} else {
for (int(i) = (c); (i) < (26); (i)++) {
f[i] = true;
dfs(v + 1, i + 1);
f[i] = false;
}
}
}
int main() {
scanf("%d%d%d", &H, &W, &K);
for (int(i) = 0; (i) < (H); (i)++) scanf("%s", &m[i]);
for (int(i) = 0; (i) < (H); (i)++)
for (int(j) = 0; (j) < (W); (j)++) {
if (m[i][j] == 'S') sx = i, sy = j;
if (m[i][j] == 'T') gx = i, gy = j;
}
dfs(0, 0);
if (cs == (1 << 29))
puts("-1");
else
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxk = 1005;
string mul(string a, string b) {
int res[Maxk];
memset(res, 0, sizeof(res));
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
for (int i = 0; i < a.length(); i++) {
for (int j = 0; j < b.length(); j++) {
res[i + j] += (a[i] - '0') * (b[j] - '0');
}
}
for (int i = 0; i < Maxk; i++) {
if (res[i] >= 10) {
res[i + 1] += (res[i] / 10);
res[i] %= 10;
}
}
string ret;
bool flag = false;
for (int i = Maxk - 1; i >= 0; i--) {
if (flag || res[i]) {
flag = true;
ret = ret + (char)(res[i] + '0');
}
}
if (ret == "") ret = "0";
return ret;
}
string add(string a, string b) {
if (a.length() < b.length()) swap(a, b);
while (a.length() != b.length()) {
b = '0' + b;
}
for (int i = a.length() - 1; i >= 0; i--) {
a[i] += (b[i] - '0');
if (a[i] > '9' && i) {
a[i] -= 10;
a[i - 1]++;
}
}
if (a[0] > '9') {
a[0] -= 10;
a = '1' + a;
}
return a;
}
inline int 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;
}
const int Maxn = 55;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
int n, m, k;
int sx, sy, ex, ey;
char c[Maxn][Maxn];
int now[5];
int cc[55555][5];
bool canc[Maxn][Maxn];
int d[55555][5], dd[55555][5];
int cnt, kd, kdd;
int dist[Maxn][Maxn];
int val[55555];
void bfs(int x, int y) {
queue<pair<int, int> > q;
dist[x][y] = 0;
q.push(make_pair(x, y));
while (!q.empty()) {
pair<int, int> coor = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
pair<int, int> nx = {coor.first + dx[i], coor.second + dy[i]};
if (nx.first >= 0 && nx.second >= 0 && nx.first < n && nx.second < m &&
dist[nx.first][nx.second] == 20160116 && canc[nx.first][nx.second]) {
dist[nx.first][nx.second] = dist[coor.first][coor.second] + 1;
q.push(nx);
}
}
}
}
string ans;
string noww;
bool vis[Maxn][Maxn];
void DD(int nx, int ny, int ex, int ey, int di) {
vector<pair<int, int> > avail, tmp;
avail.push_back(make_pair(nx, ny));
for (int i = di - 1; i >= 0; i--) {
char Mc = 'z';
tmp.clear();
for (int j = 0; j < avail.size(); j++) {
for (int kk = 0; kk < 4; kk++) {
int x = avail[j].first + dx[kk], y = avail[j].second + dy[kk];
if (x >= 0 && y >= 0 && x < n && y < m &&
dist[x][y] == dist[avail[j].first][avail[j].second] - 1) {
Mc = min(Mc, c[x][y]);
}
}
}
for (int j = 0; j < avail.size(); j++) {
for (int kk = 0; kk < 4; kk++) {
int x = avail[j].first + dx[kk], y = avail[j].second + dy[kk];
if (x >= 0 && y >= 0 && x < n && y < m &&
dist[x][y] == dist[avail[j].first][avail[j].second] - 1) {
if (c[x][y] == Mc && !vis[x][y]) {
vis[x][y] = true;
tmp.push_back(make_pair(x, y));
}
}
}
}
avail = tmp;
noww = noww + Mc;
}
if (ans == "" || ans > noww) {
ans = noww;
}
}
void Gao(int id) {
memset(canc, false, sizeof(canc));
memset(vis, false, sizeof(vis));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; j++) {
dist[i][j] = 20160116;
}
}
canc[sx][sy] = true;
canc[ex][ey] = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int l = 0; l < k; l++) {
if (c[i][j] == dd[id][l] + 'a') {
canc[i][j] = true;
}
}
}
}
bfs(ex, ey);
DD(sx, sy, ex, ey, dist[sx][sy]);
}
int check(int id) {
memset(canc, false, sizeof(canc));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; j++) {
dist[i][j] = 20160116;
}
}
canc[sx][sy] = true;
canc[ex][ey] = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int l = 0; l < k; l++) {
if (c[i][j] == cc[id][l] + 'a') {
canc[i][j] = true;
}
}
}
}
bfs(sx, sy);
if (dist[ex][ey] < 2500) return dist[ex][ey];
return 0;
}
void go(int lvl, int x) {
if (lvl == k) {
for (int i = 0; i < k; i++) {
cc[cnt][i] = now[i];
}
cnt++;
return;
}
for (int i = x; i < 26; i++) {
now[lvl] = i;
go(lvl + 1, i + 1);
}
}
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;
} else if (c[i][j] == 'T') {
ex = i;
ey = j;
}
}
}
go(0, 0);
for (int i = 0; i < cnt; i++) {
int tmp;
if (tmp = check(i)) {
for (int j = 0; j < k; j++) {
d[kd][j] = cc[i][j];
}
val[kd] = tmp;
kd++;
}
}
if (!kd) {
printf("-1\n");
return 0;
}
int Mn = 20160116;
for (int i = 0; i < kd; i++) {
Mn = min(Mn, val[i]);
}
for (int i = 0; i < kd; i++) {
if (val[i] == Mn) {
for (int j = 0; j < k; j++) {
dd[kdd][j] = d[i][j];
}
kdd++;
}
}
for (int i = 0; i < kdd; i++) {
noww.clear();
Gao(i);
}
ans.pop_back();
printf("%s\n", ans.c_str());
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))
return 1;
if (S.size() + dist(x, y, ex, ey) < b.S.size() + dist(b.x, b.y, ex, ey))
return 0;
if (S.size() + dist(x, y, ex, ey) == b.S.size() + dist(b.x, b.y, ex, ey) &&
S.compare(b.S) > 0)
return 1;
else
return 0;
}
};
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).push_back(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;
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;
int n, m, k;
char mp[60][60];
bool can[60][60];
int dist[60][60];
pair<int, int> src, trg;
queue<pair<int, int> > q;
vector<pair<int, int> > pos[300];
int dir[4][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
int best = 1000000000;
char ans[1000000];
char tans[1000000];
pair<int, int> posi[2][1000000];
int sz[2];
void f(int rem, char st) {
if (rem == 0) {
memset(dist, -1, sizeof dist);
while (!q.empty()) q.pop();
q.push(trg);
dist[trg.first][trg.second] = 0;
while (!q.empty()) {
pair<int, int> tmp = q.front();
q.pop();
if (tmp == src) break;
for (int i = 0; i < 4; i++) {
int nr = tmp.first + dir[i][0];
int nc = tmp.second + dir[i][1];
if (nr >= 0 && nc >= 0 && nr < n && nc < m && can[nr][nc] &&
dist[nr][nc] == -1) {
dist[nr][nc] = dist[tmp.first][tmp.second] + 1;
q.push(pair<int, int>(nr, nc));
}
}
}
int len = dist[src.first][src.second];
if (len != -1 && len <= best) {
int cur = 0, nx = 1;
posi[0][0] = src;
sz[0] = 1;
for (int i = len - 1; i >= 0; i--) {
sz[nx] = 0;
char mn = 'z' + 1;
for (int j = 0; j < sz[cur]; j++) {
for (int k = 0; k < 4; k++) {
int nr = posi[cur][j].first + dir[k][0];
int nc = posi[cur][j].second + dir[k][1];
if (nr >= 0 && nc >= 0 && nr < n && nc < m && dist[nr][nc] == i) {
mn = min(mn, mp[nr][nc]);
}
}
}
for (int j = 0; j < sz[cur]; j++) {
for (int k = 0; k < 4; k++) {
int nr = posi[cur][j].first + dir[k][0];
int nc = posi[cur][j].second + dir[k][1];
if (nr >= 0 && nc >= 0 && nr < n && nc < m && dist[nr][nc] == i &&
mp[nr][nc] == mn) {
posi[nx][sz[nx]++] = pair<int, int>(nr, nc);
}
}
}
sort(posi[nx], posi[nx] + sz[nx]);
int ptr = 0;
for (int j = 0; j < sz[nx]; j++) {
if (j == 0 || posi[nx][j] != posi[nx][j - 1])
posi[nx][ptr++] = posi[nx][j];
}
sz[nx] = ptr;
tans[len - i - 1] = mn;
cur = 1 - cur, nx = 1 - nx;
}
bool good = true;
if (best == len) {
for (int i = 0; i < len; i++)
if (tans[i] != ans[i]) {
if (tans[i] < ans[i])
break;
else
good = false;
}
}
if (good) {
for (int i = 0; i < len; i++) ans[i] = tans[i];
best = len;
}
}
return;
}
for (char i = st; i <= 'z'; i++) {
for (int j = 0; j < pos[i].size(); j++)
can[pos[i][j].first][pos[i][j].second] = true;
f(rem - 1, i + 1);
for (int j = 0; j < pos[i].size(); j++)
can[pos[i][j].first][pos[i][j].second] = false;
}
}
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')
src = pair<int, int>(i, j);
else if (mp[i][j] == 'T')
trg = pair<int, int>(i, j);
else
pos[mp[i][j]].push_back(pair<int, int>(i, j));
}
}
can[src.first][src.second] = true;
f(k, 'a');
if (best == 1000000000)
cout << -1 << endl;
else {
ans[best - 1] = 0;
puts(ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
string filename = "test";
int n, m, k;
vector<string> mapa;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
bool allowed[26];
int ctoi(char c) { return c - 'a'; }
int valid(int i, int j) { return i >= 0 && i < n && j >= 0 && j < m; }
pair<int, int> Q[100000];
int D[51][51];
int main() {
scanf("%d %d %d", &n, &m, &k);
string tmp_str;
for (int _n(n), i(0); i < _n; i++) {
cin >> tmp_str;
mapa.push_back(tmp_str);
}
pair<int, int> start, end;
vector<char> all_letters;
for (int _n(n), i(0); i < _n; i++)
for (int _n(m), j(0); j < _n; j++) {
if (mapa[i][j] == 'S') {
start = pair<int, int>(i, j);
} else if (mapa[i][j] == 'T') {
end = pair<int, int>(i, j);
} else {
all_letters.push_back(mapa[i][j]);
}
}
for (int _n(4), dir(0); dir < _n; dir++) {
int nx = start.first + dx[dir], ny = start.second + dy[dir];
if (valid(nx, ny) && pair<int, int>(nx, ny) == end) {
cout << "\n";
return 0;
}
}
sort(((all_letters)).begin(), ((all_letters)).end()),
(all_letters)
.erase(unique(((all_letters)).begin(), ((all_letters)).end()),
(all_letters).end());
int nn = all_letters.size();
int ires = -1;
string sres = "";
for (int _n(k + 1), kk(1); kk < _n; kk++) {
if (kk > all_letters.size()) break;
unsigned int mask = (1 << kk) - 1;
while (!(mask & (1 << nn))) {
memset(allowed, false, sizeof(allowed));
for (int _n(nn), i(0); i < _n; i++)
if (mask & (1 << i)) {
allowed[ctoi(all_letters[i])] = true;
}
int wr = 0, rd = 0;
memset(D, -1, sizeof(D));
Q[wr++] = end;
D[end.first][end.second] = 0;
while (rd < wr) {
pair<int, int> now = Q[rd++];
for (int _n(4), dir(0); dir < _n; dir++) {
int nx = now.first + dx[dir], ny = now.second + dy[dir];
if (!valid(nx, ny)) continue;
if (D[nx][ny] != -1) continue;
if (mapa[nx][ny] != 'T' && mapa[nx][ny] != 'S' &&
!allowed[ctoi(mapa[nx][ny])])
continue;
D[nx][ny] = D[now.first][now.second] + 1;
Q[wr++] = pair<int, int>(nx, ny);
}
}
int ires_now = D[start.first][start.second];
if (ires_now != -1 && !(ires != -1 && ires_now > ires)) {
string sres_now = "";
vector<pair<int, int> > pos[2];
int cur_index = 0;
pos[cur_index].push_back(start);
int d = D[start.first][start.second];
while (d != 0) {
sres_now.push_back(
mapa[pos[cur_index][0].first][pos[cur_index][0].second]);
int next_index = cur_index ^ 1;
bool exit_found = false;
char min_c = (char)('z' + 1);
for (int _n(pos[cur_index].size()), i(0); i < _n; i++) {
for (int _n(4), dir(0); dir < _n; dir++) {
int nx = pos[cur_index][i].first + dx[dir],
ny = pos[cur_index][i].second + dy[dir];
if (!valid(nx, ny)) continue;
if (D[nx][ny] == -1) continue;
if (D[nx][ny] + 1 != d) continue;
if (mapa[nx][ny] == 'T') {
exit_found = true;
break;
}
D[nx][ny] = -1;
if (mapa[nx][ny] < min_c) {
min_c = mapa[nx][ny];
pos[next_index].clear();
pos[next_index].push_back(pair<int, int>(nx, ny));
} else if (mapa[nx][ny] == min_c) {
pos[next_index].push_back(pair<int, int>(nx, ny));
}
}
if (exit_found) break;
}
if (exit_found) break;
--d;
cur_index = next_index;
}
if (ires == -1 || ires_now < ires) {
ires = ires_now;
sres = sres_now;
} else if (ires_now == ires && sres_now < sres) {
ires = ires_now;
sres = sres_now;
}
}
int lo = mask & ~(mask - 1);
int lz = (mask + lo) & ~mask;
mask |= lz;
mask &= ~(lz - 1);
mask |= (lz / lo / 2) - 1;
}
}
if (ires == -1) {
printf("-1\n");
} else {
cout << sres.substr(1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int oo = ~0u >> 2, mo = (int)1e9 + 7;
const int mn = 60, mc = 26, ml = 14, mm = 1 << ml;
const int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int a[mn][mn];
int Cnt[mm];
int n, m, k;
pair<int, int> st, ed;
int Encode(pair<int, int> t) { return t.first * m + t.second; }
pair<int, int> Decode(int t) { return make_pair(t / m, t % m); }
int dis(pair<int, int> x, pair<int, int> y) {
return abs(x.first - y.first) + abs(x.second - y.second);
}
int cntb(int x) {
int ret = 0;
while (x) ret += Cnt[x & (mm - 1)], x >>= ml;
return ret;
}
struct Node {
string path;
int col, posi;
Node(string _path, int _col, int _posi) {
path = _path, col = _col, posi = _posi;
}
long long Encode() { return (long long)col * 10000 + posi; }
bool operator<(const Node &p) const {
pair<int, int> p1 = Decode(posi), p2 = Decode(p.posi);
int d1 = (int)path.length() + dis(p1, ed);
int d2 = (int)p.path.length() + dis(p2, ed);
if (d1 != d2) return d1 > d2;
return path > p.path;
}
};
priority_queue<Node> Q;
set<long long> dup;
bool okay(0);
int main() {
for (int i = (1); i <= (mm - 1); ++i) Cnt[i] = __builtin_popcount(i);
cin >> n >> m >> k;
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1); ++j) {
char ch;
do {
scanf("%c", &ch);
} while ((ch < 'a' || ch > 'z') && ch != 'S' && ch != 'T');
if (ch == 'S')
st = make_pair(i, j), a[i][j] = mc;
else if (ch == 'T')
ed = make_pair(i, j), a[i][j] = mc + 1;
else
a[i][j] = ch - 'a';
}
Q.push(Node("", 0, Encode(st)));
while (!Q.empty() && !okay) {
Node Now = Q.top();
Q.pop();
pair<int, int> P = Decode(Now.posi);
if (a[P.first][P.second] > mc) {
cout << Now.path << endl;
okay = 1;
break;
}
if (dup.find(Now.Encode()) != dup.end()) continue;
dup.insert(Now.Encode());
for (int i = (0); i <= (3); ++i) {
pair<int, int> p = P;
p.first += fx[i][0], p.second += fx[i][1];
if (p.first < 0 || p.first >= n || p.second < 0 || p.second >= m)
continue;
if (a[p.first][p.second] == mc) continue;
string np = Now.path;
int col = Now.col;
if (a[p.first][p.second] < mc)
np += char('a' + a[p.first][p.second]),
col |= 1 << a[p.first][p.second];
Node tmp = Node(np, col, Encode(p));
if (cntb(tmp.col) > k) continue;
Q.push(tmp);
}
}
if (!okay) cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m, k;
int si, sj, ti, tj;
int was[50][50];
string g[50], res[50][50];
pair<int, int> q[2500];
int x[50][50];
int can[27];
string ANS;
int ans;
int go() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
was[i][j] = 0;
}
can[26] = 1;
int l = 0, r = 1;
q[0] = make_pair(si, sj);
was[si][sj] = 1;
while (l < r) {
int i = q[l].first;
int j = q[l].second;
if (i == ti && j == tj) break;
l++;
for (int t = 0; t < 4; t++) {
int ni = i + int(t == 0) - int(t == 1);
int nj = j + int(t == 2) - int(t == 3);
if (ni >= 0 && nj >= 0 && ni < n && nj < m && can[x[ni][nj]]) {
if (!was[ni][nj]) {
was[ni][nj] = was[i][j] + 1;
q[r++] = make_pair(ni, nj);
}
}
}
}
if (!was[ti][tj] || was[ti][tj] > ans) return 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) res[i][j] = "";
was[si][sj] = 1;
res[si][sj] = "S";
for (int l = 0; l < r; l++) {
int i = q[l].first;
int j = q[l].second;
if (i == ti && j == tj) break;
for (int t = 0; t < 4; t++) {
int ni = i + int(t == 0) - int(t == 1);
int nj = j + int(t == 2) - int(t == 3);
if (ni >= 0 && nj >= 0 && ni < n && nj < m && can[x[ni][nj]] &&
was[ni][nj] == was[i][j] + 1) {
string tmp = res[i][j] + g[ni][nj];
if (res[ni][nj] == "" || res[ni][nj] > tmp) res[ni][nj] = tmp;
}
}
}
if (was[ti][tj] < ans) {
ans = was[ti][tj];
ANS = res[ti][tj];
} else if (was[ti][tj] == ans)
ANS = min(ANS, res[ti][tj]);
return 0;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> g[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] == 'S') {
x[i][j] = 26;
si = i;
sj = j;
} else if (g[i][j] == 'T') {
x[i][j] = 26;
ti = i;
tj = j;
} else
x[i][j] = g[i][j] - 'a';
ans = 1e9;
ANS = "";
for (int a = 0; a < 26; a++) {
can[a] = 1;
if (k == 1)
go();
else
for (int b = a + 1; b < 26; b++) {
can[b] = 1;
if (k == 2)
go();
else
for (int c = b + 1; c < 26; c++) {
can[c] = 1;
if (k == 3)
go();
else
for (int d = c + 1; d < 26; d++) {
can[d] = 1;
go();
can[d] = 0;
}
can[c] = 0;
}
can[b] = 0;
}
can[a] = 0;
}
if (ANS == "")
printf("-1\n");
else
printf("%s\n", ANS.substr(1, ((int)(ANS).size()) - 2).c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int a1[4] = {0, 0, 1, -1}, a2[4] = {1, -1, 0, 0};
struct ww {
int x, y;
inline bool operator==(const ww &A) { return x == A.x && y == A.y; }
} S, T, g[60 * 60];
struct w {
int a[15];
int len;
inline bool operator<(const w &A) {
if (len < A.len) return 1;
if (len > A.len) return 0;
int i;
for (i = len / 15; i >= 0; i--) {
if (a[i] < A.a[i]) return 1;
if (a[i] > A.a[i]) return 0;
}
return 1;
}
} gg[60][60];
struct Ans {
int len;
char p[100];
inline bool operator<(const Ans &A) {
if (len < A.len) return 1;
if (len > A.len) return 0;
int i;
for (i = 1; i <= len; i++) {
if (p[i] < A.p[i]) return 1;
if (p[i] > A.p[i]) return 0;
}
return 1;
}
inline void print() {
if (len == 100)
printf("-1\n");
else {
int i;
for (i = 1; i <= len; i++) printf("%c", p[i]);
printf("\n");
}
}
} an;
int i, j, k, n, m, K;
int id[60], a[60];
char p[60][60], re[100];
inline void into(w &A, int B) {
int a1 = A.len / 15, a2 = A.len % 15;
A.len++;
A.a[a1] |= B << (2 * a2);
}
inline void work() {
int i, j, l, r;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) gg[i][j].len = 1000;
g[l = r = 1] = T;
gg[T.x][T.y].len = 0;
for (i = 0; i <= 14; i++) gg[T.x][T.y].a[i] = 0;
for (; l <= r; l++) {
ww A = g[l];
if (A == S) break;
for (i = 0; i <= 3; i++) {
int x = A.x + a1[i], y = A.y + a2[i];
ww asd = {x, y};
if (x && y && x <= n && y <= m) {
int B = id[p[x][y] - 'a' + 1];
if (!(asd == S) && !B) continue;
w C = gg[A.x][A.y];
if (!(asd == S)) into(C, B - 1);
if (C < gg[x][y]) {
if (gg[x][y].len == 1000) g[++r] = asd;
gg[x][y] = C;
}
}
}
}
if (l > r) return;
w res = gg[S.x][S.y];
if (res.len > an.len) return;
Ans ans = {};
for (i = res.len - 1; i >= 0; i--) {
int A = i / 15, B = i % 15;
int C = (res.a[A] >> (2 * B)) & 3;
ans.p[++ans.len] = 'a' + a[C + 1] - 1;
}
if (ans < an) an = ans;
}
void dfs(int x, int y) {
if (x > K) {
work();
return;
}
int i;
for (i = y + 1; i <= 26; i++) {
id[i] = x;
a[x] = i;
dfs(x + 1, i);
id[i] = 0;
}
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (i = 1; i <= n; i++) scanf("%s", p[i] + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (p[i][j] == 'S') S = (ww){i, j};
if (p[i][j] == 'T') T = (ww){i, j};
}
an.len = 100;
dfs(1, 0);
an.print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class F, class T>
T convert(F a, int p = -1) {
stringstream ss;
if (p >= 0) ss << fixed << setprecision(p);
ss << a;
T r;
ss >> r;
return r;
}
template <class T>
void db(T a, int p = -1) {
if (p >= 0) cout << fixed << setprecision(p);
cout << a << " ";
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T cube(T x) {
return x * x * x;
}
template <class T>
struct Triple {
T x, y, z;
Triple() {}
Triple(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
};
template <class T>
Triple<T> euclid(T a, T b) {
if (b == 0) return Triple<T>(1, 0, a);
Triple<T> r = euclid(b, a % b);
return Triple<T>(r.y, r.x - a / b * r.y, r.z);
}
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return s == 0 ? 0 : cntbit(s >> 1) + (s & 1);
}
const int bfsz = 1 << 16;
char bf[bfsz + 5];
int rsz = 0;
int ptr = 0;
char gc() {
if (rsz <= 0) {
ptr = 0;
rsz = fread(bf, 1, bfsz, stdin);
if (rsz <= 0) return EOF;
}
--rsz;
return bf[ptr++];
}
void ga(char &c) {
c = EOF;
while (!isalpha(c)) c = gc();
}
int gs(char s[]) {
int l = 0;
char c = gc();
while (isspace(c)) c = gc();
while (c != EOF && !isspace(c)) {
s[l++] = c;
c = gc();
}
s[l] = '\0';
return l;
}
template <class T>
bool gi(T &v) {
v = 0;
char c = gc();
while (c != EOF && c != '-' && !isdigit(c)) c = gc();
if (c == EOF) return false;
bool neg = c == '-';
if (neg) c = gc();
while (isdigit(c)) {
v = v * 10 + c - '0';
c = gc();
}
if (neg) v = -v;
return true;
}
const double PI = 2 * acos(0);
const string months[] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
const int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dr[] = {-1, 0, +1, 0};
const int dc[] = {0, +1, 0, -1};
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const double eps = 1e-9;
const long long mod = 100000007;
int n, m, k;
int a[5];
string kq, s[55];
int lenkq = inf, rs, cs, rf, cf;
pair<int, int> back[55][55];
bool cmp(pair<int, int> const &A, pair<int, int> const &B) {
return s[A.first][A.second] < s[B.first][B.second];
}
bool thoaman(int r, int c) {
if (r >= 0 && r < n && c >= 0 && c < m) {
if (s[r][c] == 'T') return true;
for (typeof(k) i = 0; i < (k); ++i)
if (a[i] == s[r][c] - 'a') return true;
return false;
}
return false;
}
string reverse(string x) {
string res = "";
for (int i = x.length() - 1; i >= 0; i--) res.push_back(x[i]);
return res;
}
void cal() {
int f[55][55], r, c, rr, cc;
memset(f, -1, sizeof(f));
f[rs][cs] = 0;
vector<pair<int, int> > que[55 * 55];
pair<int, int> temp[55 * 55];
int num;
int size = 0;
que[size++].push_back(make_pair(rs, cs));
for (typeof(size) i = 0; i < (size); ++i) {
num = 0;
for (typeof(((int)(que[i]).size())) j = 0; j < (((int)(que[i]).size()));
++j) {
r = que[i][j].first;
c = que[i][j].second;
for (typeof(4) t = 0; t < (4); ++t) {
rr = r + dr[t];
cc = c + dc[t];
if (thoaman(rr, cc)) {
if (f[rr][cc] == -1) {
f[rr][cc] = f[r][c] + 1;
back[rr][cc] = make_pair(r, c);
temp[num++] = make_pair(rr, cc);
}
}
}
}
sort(temp, temp + num, cmp);
que[size].push_back(temp[0]);
for (typeof(num - 1) j = (1); j <= (num - 1); ++j) {
if (cmp(temp[j - 1], temp[j])) {
size++;
que[size].push_back(temp[j]);
} else
que[size].push_back(temp[j]);
}
if (num > 0) size++;
}
if (f[rf][cf] == -1) return;
r = back[rf][cf].first;
c = back[rf][cf].second;
string res = "";
while (r != rs || c != cs) {
res.push_back(s[r][c]);
rr = back[r][c].first;
cc = back[r][c].second;
r = rr;
c = cc;
}
res = reverse(res);
if (res.length() < lenkq || (res.length() == lenkq && res.compare(kq) < 0)) {
kq = res;
lenkq = res.length();
}
}
void go(int id, int x) {
if (id == k) {
cal();
return;
}
for (typeof(25) i = (x); i <= (25); ++i) {
a[id] = i;
go(id + 1, i + 1);
}
}
int main() {
cin >> n >> m >> k;
for (typeof(n) i = 0; i < (n); ++i) {
cin >> s[i];
for (typeof(m) j = 0; j < (m); ++j) {
if (s[i][j] == 'S') {
rs = i;
cs = j;
}
if (s[i][j] == 'T') {
rf = i;
cf = j;
}
}
}
go(0, 0);
if (lenkq >= inf) {
printf("-1");
return 0;
}
cout << kq;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, k, xs, ys, xt, yt, l[55][55], len;
char s[55][55], c[4], d[55][55][2505], out[2505];
bool b[300], v[55][55];
bool check(char C) {
for (int i = 0; i < k; i++)
if (C == c[i]) return true;
return false;
}
int q[2505], rq, wq;
bool f1(int i, int j) { return strcmp(d[i / n][i % n], d[j / n][j % n]) < 0; }
void pro(int X, int Y, int L, char *D) {
if ((0 <= X) && (X < m) && (0 <= Y) && (Y < n) && (check(s[X][Y])) &&
(v[X][Y])) {
v[X][Y] = false;
l[X][Y] = L;
strcpy(d[X][Y], D);
d[X][Y][l[X][Y]] = s[X][Y];
l[X][Y]++;
d[X][Y][l[X][Y]] = '\0';
q[wq++] = X * n + Y;
}
}
void bfs() {
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) l[i][j] = 250000;
memset(v, true, sizeof(v));
rq = wq = 0;
l[xs][ys] = 0;
strcpy(d[xs][ys], "");
v[xs][ys] = false;
q[wq++] = xs * n + ys;
s[xt][yt] = c[0];
while (rq != wq) {
if ((rq != 0) &&
(l[q[rq] / n][q[rq] % n] != l[q[rq - 1] / n][q[rq - 1] % n]))
sort(q + rq, q + wq, f1);
int X = q[rq] / n;
int Y = q[rq] % n;
int L = l[X][Y];
char D[2505];
strcpy(D, d[X][Y]);
if ((X == xt) && (Y == yt)) {
if ((L < len) || ((L == len) && (strcmp(D, out) < 0))) {
len = L;
strcpy(out, D);
}
break;
}
if (L > len) break;
pro(X - 1, Y, L, D);
pro(X + 1, Y, L, D);
pro(X, Y - 1, L, D);
pro(X, Y + 1, L, D);
rq++;
}
}
void dfs(int z, int x) {
if (z == k) {
bfs();
} else {
for (int i = x; i <= 'z'; i++) {
if (b[i]) {
c[z] = i;
dfs(z + 1, i + 1);
}
}
}
}
int main() {
scanf("%d%d%d", &m, &n, &k);
memset(b, false, sizeof(b));
for (int i = 0; i < m; i++) {
scanf("%s", s[i]);
for (int j = 0; j < n; j++) {
if (s[i][j] == 'S') {
xs = i;
ys = j;
} else if (s[i][j] == 'T') {
xt = i;
yt = j;
} else {
b[s[i][j]] = true;
}
}
}
b['w'] = b['x'] = b['y'] = b['z'] = true;
len = 25000;
dfs(0, 'a');
if (len == 25000) {
printf("-1\n");
} else {
out[--len] = '\0';
printf("%s\n", out);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int lx, ly, lk;
char maze[55][55];
map<pair<int, int>, bool> vis;
int sx, sy;
int ex, ey;
inline int ABS(int x) { return x < 0 ? -x : x; }
inline int h(int x, int y) { return ABS(ex - x) + ABS(ey - y); }
struct S {
int x, y, t, m;
char path[500];
S() {}
S(int _x, int _y, int _t, int _m, char tpath[]) : x(_x), y(_y), t(_t), m(_m) {
strcpy(path, tpath);
}
friend bool operator<(const S& a, const S& b) {
int ha = h(a.x, a.y), hb = h(b.x, b.y);
if (ha + a.t != hb + b.t) return ha + a.t > hb + b.t;
return strcmp(a.path, b.path) > 0;
}
};
int dir[4][2] = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
char path[500];
inline int CB(int x) {
int cnt = 0;
while (x) {
x &= (x - 1);
cnt++;
}
return cnt;
}
char tpath[500];
void bfs() {
vis.clear();
priority_queue<S> que;
tpath[0] = 0;
que.push(S(sx, sy, 0, 0, tpath));
while (!que.empty()) {
S u = que.top();
que.pop();
if (vis[make_pair(u.x * 55 + u.y, u.m)]) continue;
vis[make_pair(u.x * 55 + u.y, u.m)] = true;
for (int i = 0; i < 4; i++) {
int vx = u.x + dir[i][0];
int vy = u.y + dir[i][1];
if (vx < 0 || vx >= lx) continue;
if (vy < 0 || vy >= ly) continue;
if (maze[vx][vy] == 'S') continue;
if (maze[vx][vy] == 'T') {
puts(u.path);
return;
}
int mask = u.m;
mask |= 1 << (maze[vx][vy] - 'a');
if (CB(mask) > lk) continue;
strcpy(tpath, u.path);
int len = strlen(tpath);
tpath[len] = maze[vx][vy];
tpath[len + 1] = 0;
que.push(S(vx, vy, u.t + 1, mask, tpath));
}
}
puts("-1");
}
int main() {
while (~scanf("%d%d%d", &lx, &ly, &lk)) {
for (int i = 0; i < lx; i++) {
scanf("%s", maze[i]);
for (int j = 0; j < ly; j++) {
if (maze[i][j] == 'S') {
sx = i;
sy = j;
} else if (maze[i][j] == 'T') {
ex = i;
ey = j;
}
}
}
bfs();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ii = pair<int, int>;
using vii = vector<ii>;
using l = long long;
using vl = vector<l>;
using vvl = vector<vl>;
using ll = pair<l, l>;
using vll = vector<ll>;
using vvll = vector<vll>;
using lu = unsigned long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
const int INF = numeric_limits<int>::max();
const double EPS = 1e-10;
const l e0 = 1, e5 = 100000, e6 = 1000000, e7 = 10000000, e9 = 1000000000;
const bool enable_log = false;
struct VoidStream {
void operator&(std::ostream&) {}
};
const l dx[] = {0, 0, 1, -1};
const l dy[] = {-1, 1, 0, 0};
struct point {
l x, y;
};
const l Z = 26;
const l MAX = 50;
point start, finish;
l n, m, k;
l around_start, around_finish;
l shortest;
string answer;
l D[MAX][MAX];
vector<string> M;
bool fit(l x, l y) { return (x >= 0) and (x < n) and (y >= 0) and (y < m); }
l to_bit(char c) { return e0 << (c - 'a'); }
void check(l mask) {
if ((mask & around_finish) == 0) return;
fill(&D[0][0], &D[MAX][0], 0);
queue<point> q;
q.emplace(finish);
D[finish.x][finish.y] = 1;
while (not q.empty()) {
auto u = q.front();
q.pop();
l r = D[u.x][u.y];
if (r > shortest) return;
for (l d = 0; d < 4; d++) {
l x = u.x + dx[d], y = u.y + dy[d];
if ((not fit(x, y)) or D[x][y] != 0) continue;
if (M[x][y] == 'S') {
string candidate = "";
vector<point> wave;
wave.push_back({x, y});
for (l i = r; i > 1; i--) {
vector<point> next;
char c = 'z' + 1;
for (const auto p : wave) {
for (l j = 0; j < 4; j++) {
l a = p.x + dx[j], b = p.y + dy[j];
if ((not fit(a, b)) or (D[a][b] != i)) continue;
D[a][b] = -1;
if (M[a][b] < c) {
next.clear();
c = M[a][b];
}
if (M[a][b] == c) next.push_back({a, b});
}
}
candidate += c;
swap(next, wave);
}
if (r < shortest) {
answer = candidate;
shortest = r;
} else if (candidate < answer) {
answer = candidate;
}
return;
}
if (mask & to_bit(M[x][y])) {
D[x][y] = r + 1;
q.push({x, y});
} else {
D[x][y] = -1;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
while (cin >> n >> m >> k) {
shortest = INF;
M.resize(n);
for (l i = 0; i < n; i++) cin >> M[i];
l mask = 0;
for (l i = 0; i < n; i++) {
for (l j = 0; j < m; j++) {
if (M[i][j] == 'S') {
start = {i, j};
continue;
}
if (M[i][j] == 'T') {
finish = {i, j};
continue;
}
mask = mask | to_bit(M[i][j]);
}
}
around_start = 0;
for (l d = 0; d < 4; d++) {
if (fit(start.x + dx[d], start.y + dy[d])) {
if (M[start.x + dx[d]][start.y + dy[d]] == 'T') {
shortest = 0;
break;
}
around_start =
around_start | to_bit(M[start.x + dx[d]][start.y + dy[d]]);
}
}
if (shortest == 0) {
cout << '\n';
continue;
}
around_finish = 0;
for (l d = 0; d < 4; d++) {
if (fit(finish.x + dx[d], finish.y + dy[d]))
around_finish =
around_finish | to_bit(M[finish.x + dx[d]][finish.y + dy[d]]);
}
for (l a = 0; a < Z; a++) {
if ((around_start & (e0 << a)) == 0) continue;
check(e0 << a);
if (k == 1) continue;
for (l b = 0; b < Z; b++) {
if ((b == a) or ((mask & (e0 << b)) == 0)) continue;
check((e0 << a) | (e0 << b));
if (k == 2) continue;
for (l c = b + 1; c < Z; c++) {
if ((c == a) or ((mask & (e0 << c)) == 0)) continue;
check((e0 << a) | (e0 << b) | (e0 << c));
if (k == 3) continue;
for (l d = c + 1; d < Z; d++) {
if ((d == a) or ((mask & (e0 << d)) == 0)) continue;
check((e0 << a) | (e0 << b) | (e0 << c) | (e0 << d));
}
}
}
}
if (shortest == INF) {
cout << "-1\n";
} else {
cout << answer << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
class Tqueue {
public:
Tqueue() {
h = 0;
t = 0;
sz = 0;
}
Tqueue(int n) {
Tqueue();
resize(n);
}
void resize(int n) {
if (sz > 0) free(data);
data = (T *)malloc(sizeof(T) * (n + 1));
sz = n + 1;
h = t = 0;
}
T front() { return data[h]; }
T back() { return data[t - 1]; }
int size() {
int res = t - h;
if (res < 0) res += sz;
return res;
}
int empty() { return h == t; }
void pop() {
h++;
if (h == sz) h = 0;
}
void push(T x) {
data[t++] = x;
if (t == sz) t = 0;
}
~Tqueue() {
if (sz > 0) {
free(data);
sz = 0;
}
}
private:
T *data;
int h, t, sz;
};
const string name = "c";
const int NMAX = 52;
const int KMAX = 5;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
int n, m, k;
int sx, sy, tx, ty, dist[NMAX][NMAX];
char s[NMAX][NMAX], num[KMAX];
bool may[256];
string ans;
bool good(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && may[s[x][y]]);
}
vector<pair<int, int> > tmp, now;
int used[NMAX][NMAX];
Tqueue<pair<int, int> > q(NMAX *NMAX);
void solve() {
memset(may, 0, sizeof(may));
may['S'] = may['T'] = true;
for (int i = 0; i < (int)k; i++) may[num[i]] = true;
q.push(make_pair(tx, ty));
memset(dist, 255, sizeof(dist));
dist[tx][ty] = 0;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < (int)4; i++)
if (dist[x + dx[i]][y + dy[i]] == -1 && good(x + dx[i], y + dy[i])) {
dist[x + dx[i]][y + dy[i]] = dist[x][y] + 1;
q.push(make_pair(x + dx[i], y + dy[i]));
}
}
if (dist[sx][sy] == -1) return;
now.clear();
now.push_back(make_pair(sx, sy));
string res = "";
memset(used, 0, sizeof(used));
for (int i = dist[sx][sy] - 1; i >= 0; --i) {
tmp.clear();
char min_c = num[k - 1];
for (int j = 0; j < (int)now.size(); j++) {
int xx, yy, x = now[j].first, y = now[j].second;
for (int f = 0; f < (int)4; f++) {
xx = x + dx[f], yy = y + dy[f];
if (good(xx, yy) && dist[xx][yy] == dist[x][y] - 1)
min_c = min(min_c, s[xx][yy]);
}
}
for (int j = 0; j < (int)now.size(); j++) {
int xx, yy, x = now[j].first, y = now[j].second;
for (int f = 0; f < (int)4; f++) {
xx = x + dx[f], yy = y + dy[f];
if (good(xx, yy) && dist[xx][yy] == dist[x][y] - 1 && !used[xx][yy] &&
s[xx][yy] == min_c) {
tmp.push_back(make_pair(xx, yy));
used[xx][yy] = true;
}
}
}
now = tmp;
if (i) res += min_c;
}
if (ans.length() > res.length()) ans = res;
if (ans.length() == res.length()) ans = min(ans, res);
}
void gen(int pos, char ch) {
if (pos == k) {
solve();
return;
}
if (ch > 'z') return;
gen(pos, ch + 1);
num[pos] = ch;
gen(pos + 1, ch + 1);
}
char c[NMAX][NMAX];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < (int)n; i++) cin >> s[i];
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)m; j++) {
if (s[i][j] == 'S') sx = i, sy = j;
if (s[i][j] == 'T') tx = i, ty = j;
}
ans = "";
for (int i = 0; i < (int)n * m + 1; i++) ans += "@";
gen(0, 'a');
if (ans[0] == '@')
cout << -1 << endl;
else
cout << ans.data() << endl;
cerr << clock() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 50 + 10, MAXk = 5;
char ch[MAXn][MAXn], sal[MAXk];
string ans;
int n, m, k, dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
string dis[MAXn][MAXn];
bool flag[MAXn][MAXn];
pair<int, int> S, T;
bool cmp(string &s1, string &s2) {
if (s1.empty() || s2.empty()) return s2.empty();
if (s1.size() != s2.size()) return s1.size() < s2.size();
return s1 < s2;
}
bool isok(int x, int y) {
bool smt = false;
for (int i = 1; i <= k; i++)
if (ch[x][y] == sal[i]) smt = true;
return (smt || ch[x][y] == 'T') && min(x, y) >= 0 && x < n && y < m;
}
void bfs() {
for (int i = 0; i < MAXn; i++)
for (int j = 0; j < MAXn; j++) {
dis[i][j].clear();
flag[i][j] = false;
}
vector<pair<int, int> > vec;
vec.push_back(S);
flag[S.first][S.second] = true;
for (int i = 0; i < vec.size();)
for (int j = vec.size(); i < j; i++) {
int x = vec[i].first, y = vec[i].second;
string hp = dis[x][y];
if (pair<int, int>(x, y) == T) {
if (cmp(hp, ans)) ans = hp;
return;
}
hp += ch[x][y];
for (int z = 0; z < 4; z++) {
int tmpx = x + dx[z], tmpy = y + dy[z];
if (isok(tmpx, tmpy) && cmp(hp, dis[tmpx][tmpy])) {
dis[tmpx][tmpy] = hp;
if (!flag[tmpx][tmpy]) {
flag[tmpx][tmpy] = true;
vec.push_back(pair<int, int>(tmpx, tmpy));
}
}
}
}
}
void makeit(int a, int b) {
if (b == 0) {
bfs();
return;
}
for (int i = 0; i < a; i++) {
sal[b] = 'a' + i;
makeit(i, b - 1);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> ch[i][j];
if (ch[i][j] == 'S') S = pair<int, int>(i, j);
if (ch[i][j] == 'T') T = pair<int, int>(i, j);
}
makeit(26, k);
if (ans.empty()) return cout << -1, 0;
for (int i = 1; i < ans.size(); i++) cout << ans[i];
}
|
#include <bits/stdc++.h>
using namespace std;
const string filename = "TRACK";
int n, m, k;
char a[61][61];
bool mark[61];
int d1[61][61];
int d2[61][61];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
int res_d = 1e9;
int sx, sy;
int tx, ty;
string res;
vector<pair<int, int> > tmp1;
vector<pair<int, int> > tmp2;
queue<pair<int, int> > CurrList;
void bfs() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) d1[i][j] = d2[i][j] = 1e9;
int min_d = 1e9;
string cur;
CurrList.push(pair<int, int>(tx, ty));
d2[tx][ty] = 0;
while (!CurrList.empty()) {
int x = CurrList.front().first;
int y = CurrList.front().second;
CurrList.pop();
if (x == sx && y == sy) min_d = d2[x][y];
for (int i = 0; i < 4; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (1 <= xx && xx <= n && 1 <= yy && yy <= m) {
if (a[xx][yy] == 'S' || mark[a[xx][yy] - 'a' + 1]) {
if (d2[x][y] + 1 < d2[xx][yy]) {
d2[xx][yy] = d2[x][y] + 1;
CurrList.push(pair<int, int>(xx, yy));
}
}
}
}
}
if (min_d == 1e9) return;
tmp1.clear();
tmp2.clear();
tmp1.push_back(pair<int, int>(sx, sy));
d1[sx][sy] = 0;
for (int z = 1; z <= min_d; z++) {
tmp2.clear();
char tmp = 'z' + 1;
for (int i = 0; i < tmp1.size(); i++) {
int x = tmp1[i].first;
int y = tmp1[i].second;
if (x == tx && y == ty) break;
for (int j = 0; j < 4; j++) {
int xx = x + dx[j];
int yy = y + dy[j];
if (1 <= xx && xx <= n && 1 <= yy && yy <= m) {
if (a[xx][yy] == 'T' || mark[a[xx][yy] - 'a' + 1]) {
if ((d1[x][y] + 1 + d2[xx][yy] == min_d) && d1[xx][yy] == 1e9) {
d1[xx][yy] = d1[x][y] + 1;
if (a[xx][yy] < tmp) {
tmp2.clear();
tmp2.push_back(pair<int, int>(xx, yy));
tmp = a[xx][yy];
} else if (a[xx][yy] == tmp)
tmp2.push_back(pair<int, int>(xx, yy));
}
}
}
}
}
cur += tmp;
tmp1 = tmp2;
tmp2.clear();
}
if (min_d < res_d || (min_d == res_d && cur < res)) {
res_d = min_d;
res = cur;
}
}
void query(int cur, int used) {
if (used <= k) bfs();
if (used == k) return;
for (int i = cur; i <= 26; i++) {
mark[i] = true;
query(i + 1, used + 1);
mark[i] = false;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == 'S')
sx = i, sy = j;
else if (a[i][j] == 'T')
tx = i, ty = j;
}
query(1, 0);
if (res_d == 1e9)
cout << -1;
else {
res.pop_back();
cout << res;
}
}
|
#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;
}
vector<pair<int, int> > nxt;
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;
nxt.push_back(make_pair(tp[ni][nj], d));
}
sort(nxt.begin(), nxt.end());
for (int id1 = 0, id2; id1 < nxt.size(); id1 = id2) {
int bst = -1;
for (id2 = id1; id2 < nxt.size() && nxt[id2].first == nxt[id1].first;
++id2) {
pair<pair<int, int>, int> p = to[i][j][k][nxt[id2].second];
dfs(p.first.first, p.first.second, p.second);
if (can[p.first.first][p.first.second][p.second]) {
if (bst == -1 || cmp(p, to[i][j][k][bst])) bst = nxt[id2].second;
}
}
if (~bst) {
can[i][j][k] = true;
ans[i][j][k] = bst;
return;
}
}
}
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;
const int X[] = {-1, 0, 1, 0}, Y[] = {0, 1, 0, -1}, K = 'z' - 'a' + 2;
char a[52][52];
queue<pair<int, int> > q;
int n, m, k, mini = (1 << 30), sx, sy, fx, fy;
string mn;
vector<char> p;
set<char> buk;
vector<char> b;
bool chk(int i, int j) {
return (i >= 0 && i < n && j >= 0 && j < m &&
(a[i][j] == 'S' || a[i][j] == 'T' || (int)mn.find(a[i][j]) != -1));
}
void bfs(int x1, int y1, int x2, int y2) {
vector<char> path;
path.clear();
int d[52][52], pr[52][52];
bool u[52][52] = {false};
vector<vector<pair<int, int> > > qe[K];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) d[i][j] = (1 << 30);
d[x2][y2] = 0;
q.push(make_pair(x2, y2));
int nx, ny, x, y;
pair<int, int> v;
while (!q.empty()) {
v = q.front();
x = v.first;
y = v.second;
q.pop();
for (int c = 0; c < 4; c++) {
nx = x + X[c];
ny = y + Y[c];
if (chk(nx, ny) && d[nx][ny] == (1 << 30)) {
d[nx][ny] = d[x][y] + 1;
q.push(make_pair(nx, ny));
}
}
}
if (d[x1][y1] == (1 << 30)) return;
pr[x1][y1] = -1;
u[x1][y1] = true;
for (int i = 0; i < K; i++) qe[i].resize(d[x1][y1]);
qe[K - 1][d[x1][y1] - 1].push_back(make_pair(x1, y1));
int minc = K - 1, fminc, newminc;
for (int i = d[x1][y1] - 1; i >= 0; i--) {
newminc = K;
for (int j = 0; j < qe[minc][i].size(); j++) {
fminc = K - 1;
x = qe[minc][i][j].first;
y = qe[minc][i][j].second;
for (int c = 0; c < 4; c++) {
nx = x + X[c];
ny = y + Y[c];
if (chk(nx, ny) && a[nx][ny] != 'T' && d[nx][ny] < d[x][y])
fminc = min(fminc, (int)a[nx][ny] - 'a');
}
for (int c = 0; c < 4; c++) {
nx = x + X[c];
ny = y + Y[c];
if (a[nx][ny] == 'T') {
pr[x2][y2] = c;
nx = x2 - X[pr[x2][y2]];
ny = y2 - Y[pr[x2][y2]];
while (pr[nx][ny] != -1) {
path.push_back(a[nx][ny]);
x2 = nx, y2 = ny;
nx = x2 - X[pr[x2][y2]];
ny = y2 - Y[pr[x2][y2]];
}
reverse(path.begin(), path.end());
if (d[x1][y1] < mini || d[x1][y1] == mini && path < p) {
p = path;
mini = d[x1][y1];
}
return;
}
if (chk(nx, ny) && a[nx][ny] - 'a' == fminc && d[nx][ny] < d[x][y] &&
!u[nx][ny]) {
u[nx][ny] = true;
pr[nx][ny] = c;
qe[fminc][i - 1].push_back(make_pair(nx, ny));
}
}
newminc = min(newminc, fminc);
}
minc = newminc;
}
}
void gen(int r, int ind) {
if (r == 0) {
bfs(sx, sy, fx, fy);
return;
} else if (ind >= (int)b.size())
return;
else {
mn = mn + b[ind];
gen(r - 1, ind + 1);
mn.erase(mn.size() - 1, 1);
gen(r, ind + 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];
if (a[i][j] == 'S')
sx = i, sy = j;
else if (a[i][j] == 'T')
fx = i, fy = j;
else
buk.insert(a[i][j]);
}
while (buk.size()) {
b.push_back((*buk.begin()));
buk.erase(buk.begin());
}
gen(min(k, (int)b.size()), 0);
if (mini == (1 << 30))
cout << -1;
else
for (int i = 0; i < (int)p.size(); i++) cout << p[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int inf = 10000;
string best = "";
int min = 10000;
int n, m, k;
char a[50][51];
int start = 0;
int stop = 0;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
string ret[2500];
bool hasValue[2500];
bool visted[2500];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'S')
start = i * m + j;
else if (a[i][j] == 'T')
stop = i * m + j;
}
}
int c[4];
for (int i = 0; i < k; i++) {
c[i] = i;
}
while (true) {
bool b[256];
memset(b, 0, sizeof(b));
for (int i = 0; i < k; i++) {
b[c[i] + 'a'] = true;
}
b['S'] = b['T'] = true;
queue<int> q;
q.push(stop);
memset(hasValue, 0, sizeof(hasValue));
memset(visted, 0, sizeof(visted));
ret[stop] = string("");
hasValue[stop] = true;
visted[stop] = true;
int delta[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
while (q.size() > 0) {
int v = q.front();
q.pop();
int x = v / m;
int y = v % m;
string val = string(1, a[x][y]) + ret[v];
if (a[x][y] == 'T') val = string("");
if (v == start) {
if (ret[v].size() < min) {
best = ret[v];
min = ret[v].size();
} else if (ret[v].size() == min) {
if (ret[v] < best) best = ret[v];
}
break;
}
for (int i = 0; i < 4; i++) {
int nx = x + delta[i][0];
int ny = y + delta[i][1];
int cm = nx * m + ny;
if (0 <= nx && nx < n && 0 <= ny && ny < m && b[a[nx][ny]]) {
if (!hasValue[cm] || val < ret[cm]) {
ret[cm] = val;
hasValue[cm] = true;
}
if (!visted[cm]) {
q.push(cm);
visted[cm] = true;
}
}
}
}
c[k - 1]++;
int z = k - 1;
while (c[z] >= 26 - ((k - 1) - z) && z >= 1) {
c[z - 1]++;
for (int i = z; i < k; i++) {
c[i] = c[z - 1] + i - z + 1;
}
z--;
}
if (c[0] >= 26 - k + 1) {
break;
}
}
if (min == 10000) {
cout << -1 << endl;
} else {
cout << best << endl;
}
}
|
#include <bits/stdc++.h>
const long long base = 1000000000 + 7;
using namespace std;
char area[55][55];
int area2[55][55];
int used[55][55];
pair<int, int> sdeigijodfgijs[55][55];
int go[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int leng[55 * 55];
int ccnt[55 * 55];
void solve() {
int n, m, k;
cin >> n >> m >> k;
int si = -1, sj = -1, ti = -1, tj = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> area[i][j];
if (area[i][j] == 'S') {
si = i;
sj = j;
}
if (area[i][j] == 'T') {
ti = i;
tj = j;
}
area2[i][j] = (int)area[i][j] - 'a';
if (area[i][j] == 'S') area2[i][j] = -2;
if (area[i][j] == 'T') area2[i][j] = -1;
}
assert(si != -1 && ti != -1);
int F = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) used[i][j] = 0;
string res = "";
swap(si, ti);
swap(sj, tj);
int len = (int)1e9;
for (int a = 0; a < 26; a++)
for (int b = a + (int)(k > 1); b < 26; b++)
for (int c = b + (int)(k > 2); c < 26; c++)
for (int d = c + (int)(k > 3); d < 26; d++) {
int ch[4] = {a, b, c, d};
for (int i = k; i < 4; i++) ch[i] = ch[k - 1];
F++;
priority_queue<pair<int, pair<int, pair<int, pair<int, int> > > > > q;
q.push(make_pair(0, make_pair(0, make_pair(0, make_pair(si, sj)))));
used[si][sj] = F;
int poss = (1 << ch[0]) | (1 << ch[1]) | (1 << ch[2]) | (1 << ch[3]);
while (!q.empty()) {
pair<int, pair<int, pair<int, pair<int, int> > > > u = q.top();
q.pop();
if (leng[-u.first] != F) {
leng[-u.first] = F;
ccnt[-u.first + 1] = 0;
}
pair<int, pair<int, int> > goal[4];
int cnt = 0;
for (int i = 0; i < 4; i++) {
pair<int, int> to =
make_pair(u.second.second.second.first + go[i][0],
u.second.second.second.second + go[i][1]);
if (to.first >= 0 && to.first < n && to.second >= 0 &&
to.second < m && used[to.first][to.second] != F &&
(area2[to.first][to.second] == -2 ||
(poss & (1 << (area2[to.first][to.second])))))
goal[cnt++] = make_pair(area2[to.first][to.second], to);
}
for (int i = 0; i < cnt; i++) {
if (used[goal[i].second.first][goal[i].second.second] == F)
continue;
used[goal[i].second.first][goal[i].second.second] = F;
sdeigijodfgijs[goal[i].second.first][goal[i].second.second] =
u.second.second.second;
ccnt[-u.first + 1]++;
q.push(make_pair(
u.first - 1,
make_pair(-goal[i].first,
make_pair(-ccnt[-u.first + 1],
make_pair(goal[i].second.first,
goal[i].second.second)))));
}
}
if (used[ti][tj] != F) continue;
string ans = "";
pair<int, int> c = sdeigijodfgijs[ti][tj];
while (1) {
if (c == make_pair(si, sj)) break;
ans.push_back(area[c.first][c.second]);
c = sdeigijodfgijs[c.first][c.second];
}
if (len > (int)ans.size()) {
len = ans.size();
res = ans;
} else if (len == (int)ans.size() && ans < res)
res = ans;
}
if (len < n * m * 2)
cout << res << endl;
else
cout << -1 << endl;
}
int main() {
ios_base ::sync_with_stdio(false);
int test = 1;
while (test--) {
solve();
}
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 N = 55;
int n, m, k, sx, sy, tx, ty, d[N][N], mp[1 << 8], mrk[N][N];
int dx[] = {+1, -1, 0, 0};
int dy[] = {0, 0, +1, -1};
char str[N][N];
int chk(int x, int y) {
return x >= 1 && x <= n && y >= 1 && y <= m && mp[str[x][y]];
}
int len = 1e9;
string ans;
void bfs() {
memset(d, 0x3f, sizeof d);
d[tx][ty] = 0;
queue<pair<int, int> > q;
q.push(make_pair(tx, ty));
while (!q.empty()) {
int x, y;
tie(x, y) = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int ax = x + dx[i], ay = y + dy[i];
if (chk(ax, ay) && d[ax][ay] > d[x][y] + 1) {
d[ax][ay] = d[x][y] + 1;
q.push(make_pair(ax, ay));
}
}
}
if (d[sx][sy] > n * m) return;
string s;
q.push(make_pair(sx, sy));
while (!q.empty()) {
char mx = 'z';
queue<pair<int, int> > qq;
while (!q.empty()) {
int x, y;
tie(x, y) = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int ax = x + dx[i], ay = y + dy[i];
if (chk(ax, ay) && d[ax][ay] == d[x][y] - 1) {
mx = min(mx, str[ax][ay]);
if (!mrk[ax][ay]) {
mrk[ax][ay] = 1;
qq.push(make_pair(ax, ay));
}
}
}
}
if (mx >= 'a' && mx <= 'z') s.push_back(mx);
while (!qq.empty()) {
int x, y;
tie(x, y) = qq.front();
if (str[x][y] == mx) q.push(qq.front());
mrk[x][y] = 0;
qq.pop();
}
}
if (d[sx][sy] < len) {
len = d[sx][sy];
ans = s;
} else if (d[sx][sy] == len)
ans = min(ans, s);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> str[i] + 1;
for (int j = 1; j <= m; j++) {
if (str[i][j] == 'S') sx = i, sy = j;
if (str[i][j] == 'T') tx = i, ty = j;
}
}
mp['S'] = mp['T'] = 1;
for (int p = 0; p < 26; p++) {
for (int q = p; q < 26; q++) {
for (int r = q; r < 26; r++) {
for (int s = r; s < 26; s++) {
mp[p + 'a'] = mp[q + 'a'] = mp[r + 'a'] = mp[s + 'a'] = 1;
int cnt = 1 + (q > p) + (r > q) + (s > r);
if (cnt <= k) {
bfs();
}
mp[p + 'a'] = mp[q + 'a'] = mp[r + 'a'] = mp[s + 'a'] = 0;
}
}
}
}
if (len > n * m)
cout << -1 << endl;
else {
ans.pop_back();
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const string name = "c";
const int NMAX = 52;
const int KMAX = 5;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
int n, m, k;
int sx, sy, tx, ty, dist[NMAX][NMAX];
char s[NMAX][NMAX], num[KMAX];
bool may[256];
string ans;
bool good(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && may[s[x][y]]);
}
vector<pair<int, int> > tmp, now;
int used[NMAX][NMAX];
queue<pair<int, int> > q;
void solve() {
memset(may, 0, sizeof(may));
may['S'] = may['T'] = true;
for (int i = 0; i < (int)k; i++) may[num[i]] = true;
q.push(make_pair(tx, ty));
memset(dist, 255, sizeof(dist));
dist[tx][ty] = 0;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < (int)4; i++)
if (dist[x + dx[i]][y + dy[i]] == -1 && good(x + dx[i], y + dy[i])) {
dist[x + dx[i]][y + dy[i]] = dist[x][y] + 1;
q.push(make_pair(x + dx[i], y + dy[i]));
}
}
if (dist[sx][sy] == -1) return;
now.clear();
now.push_back(make_pair(sx, sy));
string res = "";
memset(used, 0, sizeof(used));
for (int i = dist[sx][sy] - 1; i >= 0; --i) {
tmp.clear();
char min_c = num[k - 1];
for (int j = 0; j < (int)now.size(); j++) {
int xx, yy, x = now[j].first, y = now[j].second;
for (int f = 0; f < (int)4; f++) {
xx = x + dx[f], yy = y + dy[f];
if (good(xx, yy) && dist[xx][yy] == dist[x][y] - 1)
min_c = min(min_c, s[xx][yy]);
}
}
for (int j = 0; j < (int)now.size(); j++) {
int xx, yy, x = now[j].first, y = now[j].second;
for (int f = 0; f < (int)4; f++) {
xx = x + dx[f], yy = y + dy[f];
if (good(xx, yy) && dist[xx][yy] == dist[x][y] - 1 && !used[xx][yy] &&
s[xx][yy] == min_c) {
tmp.push_back(make_pair(xx, yy));
used[xx][yy] = true;
}
}
}
now = tmp;
if (i) res += min_c;
}
if (ans.length() > res.length()) ans = res;
if (ans.length() == res.length()) ans = min(ans, res);
}
void gen(int pos, char ch) {
if (pos == k) {
solve();
return;
}
if (ch > 'z') return;
gen(pos, ch + 1);
num[pos] = ch;
gen(pos + 1, ch + 1);
}
char c[NMAX][NMAX];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < (int)n; i++) cin >> s[i];
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)m; j++) {
if (s[i][j] == 'S') sx = i, sy = j;
if (s[i][j] == 'T') tx = i, ty = j;
}
ans = "";
for (int i = 0; i < (int)n * m + 1; i++) ans += "@";
gen(0, 'a');
if (ans[0] == '@')
cout << -1 << endl;
else
cout << ans.data() << endl;
cerr << clock() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 51, A = 26;
int n, m, k, dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1}, mark[A];
vector<pair<int, int> > q1, q2;
pair<int, int> s, t;
string dis[N][N], a[N], ans;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (~a[i].find('S')) s = {i, a[i].find('S')};
if (~a[i].find('T')) t = {i, a[i].find('T')};
}
fill(mark, mark + k, 1);
sort(mark, mark + A);
do {
for (q1.push_back(s), dis[s.first][s.second] = "S"; q1.size(); q2.clear()) {
sort(q1.begin(), q1.end(), [](pair<int, int> x, pair<int, int> y) {
return dis[x.first][x.second] < dis[y.first][y.second];
});
for (auto [x, y] : q1)
for (int i = 0; i < 4; i++) {
int z = x + dx[i], t = y + dy[i];
if (~z && z < n && ~t && t < m && dis[z][t] == "" &&
(a[z][t] == 'T' || mark[a[z][t] - 'a'])) {
q2.push_back({z, t});
dis[z][t] = dis[x][y] + a[z][t];
}
}
q1 = q2;
}
string tmp = dis[t.first][t.second];
if (tmp != "" && (ans == "" || ans.size() > tmp.size() ||
(ans.size() == tmp.size() && ans > tmp)))
ans = tmp;
fill(*dis, *end(dis), "");
} while (next_permutation(mark, mark + A));
cout << (ans == "" ? "-1" : ans.substr(1, ans.size() - 2)) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55;
struct node {
string route;
int x, y, hash, alr;
node(int x_, int y_, int hash_, int alr_, string route_) {
x = x_;
y = y_;
hash = hash_;
alr = alr_;
route = route_;
}
friend bool operator<(const node &a, const node &b) {
if (a.route.length() != b.route.length())
return a.route.length() > b.route.length();
return a.route > b.route;
}
};
int n, m, k;
set<int> visit[MAXN][MAXN];
char s[MAXN][MAXN];
int pre[MAXN][MAXN];
priority_queue<node> q;
bool inside(int x, int y) { return (x >= 0 && x < n && y >= 0 && y < m); }
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void bfs(int sx, int sy) {
q.push(node(sx, sy, 0, 0, ""));
while (!q.empty()) {
node u = q.top();
q.pop();
int x = u.x, y = u.y;
for (int i = 0; i < 4; i++) {
int lx = x + dx[i];
int ly = y + dy[i];
if (!inside(lx, ly)) continue;
if (s[lx][ly] == 'T') {
cout << u.route << endl;
exit(0);
}
if (s[lx][ly] == 'S') continue;
int lhash = u.hash | (1 << (s[lx][ly] - 'a'));
if (visit[lx][ly].find(lhash) != visit[lx][ly].end()) continue;
if (pre[lx][ly] != 0 && (pre[lx][ly] & lhash) == pre[lx][ly]) continue;
pre[lx][ly] = lhash;
int newalr = u.alr + 1 - ((u.hash >> (s[lx][ly] - 'a') & 1));
if (newalr > k) continue;
visit[lx][ly].insert(lhash);
q.push(node(lx, ly, lhash, newalr, u.route + s[lx][ly]));
}
}
}
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') bfs(i, j);
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 51, MAX2 = 26;
char mm[MAX][MAX];
int tm[MAX][MAX];
int n, m, k;
struct node {
int st;
int con[MAX2];
int rev[MAX2];
node(int a = 0) : st(a) {
memset(con, -1, sizeof(con));
memset(rev, -1, sizeof(rev));
}
};
node stt[17905];
int stn;
int si, sj, ti, tj;
int dist[MAX - 1][MAX - 1][17905];
const int M1 = 10000000, M2 = 100000, M3 = 100;
struct nn {
int x, y, id;
nn(int a = 0, int b = 0, int c = 0) : x(a), y(b), id(c) {}
void print() {
printf("%d %d %d %s\n", x, y, id,
bitset<20>(stt[id].st).to_string().data());
}
};
int as(nn h) { return h.x * M1 + h.y * M2 + h.id; }
nn de(int st) { return {st / M1, st / M2 % M3, st % M2}; }
int dir[4][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
inline bool ic(int i, int j) { return i >= 0 && i < n && j >= 0 && j < m; }
vector<pair<int, int> > adj[MAX][MAX];
unordered_map<int, int> mbs;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", mm[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mm[i][j] == 'S')
si = i, sj = j;
else if (mm[i][j] == 'T')
ti = i, tj = j;
else
tm[i][j] = mm[i][j] - 'a';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int d = 0; d < 4; d++) {
int i1 = i + dir[d][0], j1 = j + dir[d][1];
if (ic(i1, j1)) {
adj[i][j].push_back({i1, j1});
}
}
}
}
stn = 0;
for (int i = 0; i < (1 << MAX2); i++) {
int bs = __builtin_popcount(i);
if (bs <= k) {
stt[stn] = {i};
mbs[i] = stn++;
}
}
for (int i = 0; i < stn; i++) {
int st = stt[i].st;
for (int j = 0; j < MAX2; j++) {
int sn = st | (1 << j);
int num = __builtin_popcount(sn);
if (num <= k) stt[i].con[j] = mbs[sn];
}
for (int j = 0; j < MAX2; j++) {
if (st & (1 << j)) {
int st1 = st & ~(1 << j);
stt[i].rev[j] = mbs[st1];
}
}
}
memset(dist, -1, sizeof(dist));
queue<int> Q;
dist[ti][tj][0] = 0;
Q.push(as({ti, tj, 0}));
bool find = 0;
while (!Q.empty()) {
int cur1 = Q.front();
nn cur = de(cur1);
Q.pop();
int curst = cur.id;
int x = cur.x, y = cur.y;
for (int i = 0; i < adj[x][y].size(); i++) {
auto &ele = adj[x][y][i];
int x1 = ele.first, y1 = ele.second;
if (x1 == ti && y1 == tj) continue;
int hst;
if (x1 == si && y1 == sj) {
hst = curst;
if (dist[x1][y1][hst] == -1) {
dist[x1][y1][hst] = dist[x][y][curst] + 1;
find = 1;
}
} else {
hst = stt[curst].con[tm[x1][y1]];
if (hst != -1) {
if (dist[x1][y1][hst] == -1) {
dist[x1][y1][hst] = dist[x][y][curst] + 1;
Q.push(as({x1, y1, hst}));
}
}
}
}
}
if (!find)
printf("-1\n");
else {
int ml = INT_MAX;
string ans;
for (int i = 0; i < stn; i++) {
if (dist[si][sj][i] != -1) ml = min(ml, dist[si][sj][i]);
}
unordered_set<int> prev;
for (int i = 0; i < stn; i++) {
if (dist[si][sj][i] == ml) prev.insert(as({si, sj, i}));
}
while (ml > 1) {
int mz = INT_MAX;
unordered_set<int> news;
for (int ele : prev) {
nn cur = de(ele);
int x = cur.x, y = cur.y;
int st, st2;
st = cur.id;
for (int d = 0; d < 4; d++) {
int x1 = x + dir[d][0], y1 = y + dir[d][1];
if (ic(x1, y1)) {
if (dist[x1][y1][st] == ml - 1) mz = min(mz, tm[x1][y1]);
if (!(x == si && y == sj)) {
st2 = stt[st].rev[tm[x][y]];
if (dist[x1][y1][st2] == ml - 1) mz = min(mz, tm[x1][y1]);
}
}
}
}
for (int ele : prev) {
nn cur = de(ele);
int x = cur.x, y = cur.y;
int st, st2;
st = cur.id;
for (int d = 0; d < 4; d++) {
int x1 = x + dir[d][0], y1 = y + dir[d][1];
if (ic(x1, y1)) {
if (dist[x1][y1][st] == ml - 1)
if (tm[x1][y1] == mz) news.insert(as({x1, y1, st}));
if (!(x == si && y == sj)) {
st2 = stt[st].rev[tm[x][y]];
if (dist[x1][y1][st2] == ml - 1 && tm[x1][y1] == mz)
news.insert(as({x1, y1, st2}));
}
}
}
}
ans.push_back('a' + mz);
prev = move(news);
ml--;
}
printf("%s\n", ans.data());
}
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;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int n, m, k;
string a[55];
string ans;
int dist = inf;
bool can[55][55];
vector<char> v;
bool ok(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
void fill(vector<char> &v) {
map<char, bool> was;
for (int i = 0; i < v.size(); i++) was[v[i]] = 1;
was['S'] = 1;
was['T'] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
can[i][j] = was[a[i][j]];
}
}
}
int level[55][55];
int d[55][55];
string solve() {
memset(d, -1, sizeof d);
queue<pair<int, int> > q;
int endx = -1, endy = -1;
int startx = -1, starty = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'T') {
q.push(make_pair(i, j));
d[i][j] = 0;
startx = i;
starty = j;
}
if (a[i][j] == 'S') {
endx = i;
endy = j;
}
}
}
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int x = p.first;
int y = p.second;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (ok(nx, ny) && can[nx][ny] && d[nx][ny] == -1) {
q.push(make_pair(nx, ny));
d[nx][ny] = d[x][y] + 1;
}
}
}
if (d[endx][endy] == -1) {
string ans = "";
ans += (char)('z' + 1);
return ans;
}
string ans = "";
int len = d[endx][endy];
vector<pair<int, int> > cur;
cur.push_back(make_pair(endx, endy));
while (len) {
vector<pair<char, pair<int, int> > > temp;
for (int i = 0; i < cur.size(); i++) {
int x = cur[i].first;
int y = cur[i].second;
for (int j = 0; j < 4; j++) {
int nx = x + dx[j];
int ny = y + dy[j];
if (ok(nx, ny) && d[nx][ny] == len - 1) {
temp.push_back(make_pair(a[nx][ny], make_pair(nx, ny)));
}
}
}
sort(temp.begin(), temp.end());
temp.resize(unique(temp.begin(), temp.end()) - temp.begin());
int en = 0;
while (en < temp.size() && temp[en].first == temp[0].first) en++;
vector<pair<int, int> > tmp;
for (int i = 0; i < en; i++) tmp.push_back(temp[i].second);
ans += temp[0].first;
cur = tmp;
len--;
}
ans.erase((int)ans.size() - 1);
return ans;
}
void go(int ind, char last = (char)('a' - 1)) {
if (ind == k) {
fill(v);
string cur = solve();
if (cur[0] > 'z') return;
if (cur.size() < dist) {
dist = cur.size();
ans = cur;
} else if (cur.size() == dist) {
ans = min(ans, cur);
}
return;
}
for (char x = last + 1; x <= 'z'; x++) {
v.push_back(x);
go(ind + 1, x);
v.pop_back();
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> a[i];
ans += (char)('z' + 1);
go(0);
if (ans[0] == (char)('z' + 1))
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
string s[N][N], a[N], ans;
int n, m, k, dis[N][N], x1, z, d = 1e9, x, y, e1, e2;
bool mark[N][N];
vector<pair<int, int> > l;
int X[4] = {0, 1, 0, -1};
int Y[4] = {1, 0, -1, 0};
bool valid(int f1, int f2) {
if (f1 <= 0 or f2 <= 0 or f1 > n or f2 > m or !mark[f1][f2]) return false;
return true;
}
void bfs() {
mark[e1][e2] = 1;
l.clear();
l.push_back({x1, z});
dis[x1][z] = 0;
for (int i = 0; i < l.size(); i++) {
x = l[i].first, y = l[i].second;
for (int j = 0; j < 4; j++) {
int xnow = X[j] + x, ynow = Y[j] + y;
if (valid(xnow, ynow)) {
if (dis[xnow][ynow] == dis[x][y] + 1)
s[xnow][ynow] = min(s[xnow][ynow], s[x][y] + a[xnow][ynow - 1]);
else if (dis[xnow][ynow] > dis[x][y]) {
dis[xnow][ynow] = dis[x][y] + 1;
s[xnow][ynow] = s[x][y] + a[xnow][ynow - 1];
l.push_back({xnow, ynow});
}
}
}
}
if (dis[e1][e2] == d)
ans = min(ans, s[e1][e2]);
else if (dis[e1][e2] < d) {
ans = s[e1][e2];
d = dis[e1][e2];
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == 'S')
x1 = i, z = j + 1;
else if (a[i][j] == 'T')
e1 = i, e2 = j + 1;
if (k == 4) {
for (int i1 = 0; i1 < 26; i1++) {
for (int i2 = i1 + 1; i2 < 26; i2++) {
for (int i3 = i2 + 1; i3 < 26; i3++) {
for (int i4 = i3 + 1; i4 < 26; i4++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j - 1] - 'a' == i1 or a[i][j - 1] - 'a' == i2 or
a[i][j - 1] - 'a' == i3 or a[i][j - 1] - 'a' == i4)
mark[i][j] = 1;
else
mark[i][j] = 0;
dis[i][j] = 1e9;
}
bfs();
}
}
}
}
}
if (k == 3) {
for (int i1 = 0; i1 < 26; i1++) {
for (int i2 = i1 + 1; i2 < 26; i2++) {
for (int i3 = i2 + 1; i3 < 26; i3++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j - 1] - 'a' == i1 or a[i][j - 1] - 'a' == i2 or
a[i][j - 1] - 'a' == i3)
mark[i][j] = 1;
else
mark[i][j] = 0;
dis[i][j] = 1e9;
}
bfs();
}
}
}
}
if (k == 2) {
for (int i1 = 0; i1 < 26; i1++) {
for (int i2 = i1 + 1; i2 < 26; i2++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j - 1] - 'a' == i1 or a[i][j - 1] - 'a' == i2)
mark[i][j] = 1;
else
mark[i][j] = 0;
dis[i][j] = 1e9;
}
bfs();
}
}
}
if (k == 1) {
for (int i1 = 0; i1 < 26; i1++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j - 1] - 'a' == i1)
mark[i][j] = 1;
else
mark[i][j] = 0;
dis[i][j] = 1e9;
}
bfs();
}
}
if (d == 1e9) return cout << -1, 0;
for (int i = 0; i < ans.size() - 1; i++) cout << ans[i];
}
|
#include <bits/stdc++.h>
using namespace std;
const int c[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
bool f[30], vis[60][60];
char a[60][60];
int n, m, K, d[60][60];
string ans;
pair<int, int> S, T;
queue<pair<int, int> > Q;
vector<pair<int, int> > b;
void bfs() {
memset(d, 63, sizeof(d));
int inf = d[0][0];
d[T.first][T.second] = 0;
Q.push(T);
while (!Q.empty()) {
int x0 = Q.front().first, y0 = Q.front().second;
Q.pop();
for (int i = 0; i < 4; i++) {
int x = x0 + c[i][0], y = y0 + c[i][1];
if (x > 0 && x <= n && y > 0 && y <= m && d[x0][y0] + 1 < d[x][y] &&
(a[x][y] == 'S' || f[a[x][y] - 'a'])) {
d[x][y] = d[x0][y0] + 1;
Q.push(make_pair(x, y));
}
}
}
if (d[S.first][S.second] == inf) return;
string now;
Q.push(S);
memset(vis, 0, sizeof(vis));
vis[S.first][S.second] = true;
while (1) {
char ch = 'z' + 1;
b.clear();
while (!Q.empty()) {
int x0 = Q.front().first, y0 = Q.front().second;
Q.pop();
for (int i = 0; i < 4; i++) {
int x = x0 + c[i][0], y = y0 + c[i][1];
if (x > 0 && x <= n && y > 0 && y <= m && d[x0][y0] == d[x][y] + 1) {
if (a[x][y] < ch) {
b.clear();
ch = a[x][y];
}
if (a[x][y] == ch && !vis[x][y]) b.push_back(make_pair(x, y));
vis[x][y] = true;
}
}
}
if (b.size() == 0 || ch == 'T') break;
now += ch;
for (int i = 0; i < b.size(); i++) Q.push(b[i]);
}
if (now.size() < ans.size() || now.size() == ans.size() && now < ans)
ans = now;
}
void dfs(int dep, int last) {
if (dep > K) return;
bfs();
for (int i = last + 1; i < 26; i++) {
f[i] = true;
dfs(dep + 1, i);
f[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 i = 1; i <= n * m; i++) ans += 'z';
ans += 'z';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j] == 'S') S = make_pair(i, j);
if (a[i][j] == 'T') T = make_pair(i, j);
}
for (int i = 0; i < 26; i++) {
f[i] = true;
dfs(1, i);
f[i] = false;
}
if (ans.size() == n * m + 1)
printf("-1\n");
else
printf("%s\n", ans.c_str());
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
string res;
int c[26], w[26];
bool vis[26];
int f[60][60];
char g[60][60];
int n, m, k, s1, s2, tot, step;
int way[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
struct In {
int l;
int r;
string ss;
} s[3000];
void bfs() {
memset(f, -1, sizeof(f));
int i, j, first = 0, last = 1, len = 1, move = 1, ll;
s[0].l = s1;
s[0].r = s2;
s[0].ss = "";
f[s1][s2] = 0;
string a;
bool z = false;
while (first < last) {
for (i = first; i < last; i++) {
for (j = 0; j < 4; j++) {
int p, q;
p = s[i].l + way[j][0];
q = s[i].r + way[j][1];
if (p >= 0 && p < n && q >= 0 && q < m) {
if (f[p][q] != -1 && f[p][q] < move) continue;
a = s[i].ss;
if (g[p][q] == 'T') {
if (res == "") {
res = a;
step = move;
} else {
int x1 = a.length(), x2 = res.length();
if (x1 < x2 || (x1 == x2 && a < res)) {
res = a;
if (move < step) step = move;
}
}
z = true;
} else if (!z) {
bool zz = false;
for (ll = 0; ll < tot && ll < k; ll++) {
if (w[ll] == g[p][q] - 'a') {
zz = true;
break;
}
}
if (zz) {
a += g[p][q];
for (ll = last; ll < len; ll++)
if (s[ll].l == p && s[ll].r == q) {
if (s[ll].ss > a) s[ll].ss = a;
break;
}
if (ll == len) {
s[len].l = p;
s[len].r = q;
s[len].ss = a;
len++;
f[p][q] = move;
}
}
}
}
}
}
if (z) break;
first = last;
last = len;
move++;
if (move > step) break;
}
}
void dfs(int x, int y) {
if (x == tot) return;
w[y] = c[x];
if (y == k - 1) {
bfs();
} else
dfs(x + 1, y + 1);
dfs(x + 1, y);
}
int main() {
while (cin >> n >> m >> k) {
int i, j;
tot = 0;
memset(vis, 0, sizeof(vis));
for (i = 0; i < n; i++) {
cin >> g[i];
for (j = 0; j < m; j++) {
if (g[i][j] == 'S') {
s1 = i;
s2 = j;
} else if (g[i][j] >= 'a' && g[i][j] <= 'z') {
if (!vis[g[i][j] - 'a']) {
c[tot++] = g[i][j] - 'a';
vis[g[i][j] - 'a'] = 1;
}
}
}
}
step = 3000;
if (tot <= k) {
for (i = 0; i < tot; i++) w[i] = c[i];
bfs();
} else
dfs(0, 0);
if (step == 3000)
cout << -1 << endl;
else
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
class Tqueue {
public:
Tqueue() {
h = 0;
t = 0;
sz = 0;
}
Tqueue(int n) {
Tqueue();
resize(n);
}
void resize(int n) {
if (sz > 0) free(data);
data = (T *)malloc(sizeof(T) * (n + 1));
sz = n + 1;
h = t = 0;
}
T front() {
if (h == t) cerr << "ERROR! Tqueue:front() for empty queue!" << endl;
return data[h];
}
T back() {
if (h == t) cerr << "ERROR! Tqueue:back() for empty queue!" << endl;
return data[t - 1];
}
int size() {
int res = t - h;
if (res < 0) res += sz;
return res;
}
int empty() { return h == t; }
void pop() {
if (h == t) cerr << "ERROR! Tqueue:pop() for empty queue!" << endl;
h++;
if (h == sz) h = 0;
}
void push(T x) {
data[t++] = x;
if (t == sz) t = 0;
if (h == t) cerr << "ERROR! Tqueue:push() for full queue!" << endl;
}
~Tqueue() {
if (sz > 0) {
free(data);
sz = 0;
}
}
private:
T *data;
int h, t, sz;
};
const string name = "c";
const int NMAX = 52;
const int KMAX = 5;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
int n, m, k;
int sx, sy, tx, ty, dist[NMAX][NMAX];
char s[NMAX][NMAX], num[KMAX];
bool may[256];
string ans;
bool good(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && may[s[x][y]]);
}
vector<pair<int, int> > tmp, now;
int used[NMAX][NMAX];
Tqueue<pair<int, int> > q(NMAX *NMAX);
void solve() {
memset(may, 0, sizeof(may));
may['S'] = may['T'] = true;
for (int i = 0; i < (int)k; i++) may[num[i]] = true;
q.push(make_pair(tx, ty));
memset(dist, 255, sizeof(dist));
dist[tx][ty] = 0;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < (int)4; i++)
if (dist[x + dx[i]][y + dy[i]] == -1 && good(x + dx[i], y + dy[i])) {
dist[x + dx[i]][y + dy[i]] = dist[x][y] + 1;
q.push(make_pair(x + dx[i], y + dy[i]));
}
}
if (dist[sx][sy] == -1) return;
now.clear();
now.push_back(make_pair(sx, sy));
string res = "";
memset(used, 0, sizeof(used));
for (int i = dist[sx][sy] - 1; i >= 0; --i) {
tmp.clear();
char min_c = num[k - 1];
for (int j = 0; j < (int)now.size(); j++) {
int xx, yy, x = now[j].first, y = now[j].second;
for (int f = 0; f < (int)4; f++) {
xx = x + dx[f], yy = y + dy[f];
if (good(xx, yy) && dist[xx][yy] == dist[x][y] - 1)
min_c = min(min_c, s[xx][yy]);
}
}
for (int j = 0; j < (int)now.size(); j++) {
int xx, yy, x = now[j].first, y = now[j].second;
for (int f = 0; f < (int)4; f++) {
xx = x + dx[f], yy = y + dy[f];
if (good(xx, yy) && dist[xx][yy] == dist[x][y] - 1 && !used[xx][yy] &&
s[xx][yy] == min_c) {
tmp.push_back(make_pair(xx, yy));
used[xx][yy] = true;
}
}
}
now = tmp;
if (i) res += min_c;
}
if (ans.length() > res.length()) ans = res;
if (ans.length() == res.length()) ans = min(ans, res);
}
void gen(int pos, char ch) {
if (pos == k) {
solve();
return;
}
if (ch > 'z') return;
gen(pos, ch + 1);
num[pos] = ch;
gen(pos + 1, ch + 1);
}
char c[NMAX][NMAX];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < (int)n; i++) cin >> s[i];
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)m; j++) {
if (s[i][j] == 'S') sx = i, sy = j;
if (s[i][j] == 'T') tx = i, ty = j;
}
ans = "";
for (int i = 0; i < (int)n * m + 1; i++) ans += "@";
gen(0, 'a');
if (ans[0] == '@')
cout << -1 << endl;
else
cout << ans.data() << endl;
cerr << clock() << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.