text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
srand(time(0));
cout << fixed << setprecision(9);
int n, m;
cin >> n >> m;
vector<int> w(n);
for (int i = 0; i < n; ++i) cin >> w[i];
vector<int> b(m);
for (int j = 0; j < m; ++j) cin >> b[j], --b[j];
vector<int> used(n, 0);
vector<int> d;
for (int i = 0; i < m; ++i)
if (!used[b[i]]) {
d.push_back(b[i]);
used[b[i]] = 1;
}
for (int i = 0; i < n; ++i)
if (!used[i]) d.push_back(i);
long long ans = 0;
for (int i = 0; i < m; ++i) {
int j;
for (j = 0; j < n; ++j) {
if (b[i] == d[j]) break;
ans += w[d[j]];
}
for (int k = j; k > 0; --k) swap(d[k], d[k - 1]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[510];
int b[1100];
int a[510], f[510];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
memset(f, 0, sizeof(f));
int tot = 0;
for (int i = 1; i <= m; i++)
if (!f[b[i]]) {
f[b[i]] = 1;
a[++tot] = b[i];
}
int ans = 0;
for (int i = 1; i <= m; i++) {
int j;
for (j = 1; j <= n; j++) {
if (a[j] == b[i]) break;
ans += w[a[j]];
}
int t = a[j];
for (int k = j; k > 1; k--) a[k] = a[k - 1];
a[1] = t;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int w[n], b[m], ans = 0;
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < m; i++) cin >> b[i];
for (int i = 0; i < m; i++) {
map<int, int> mp;
for (int j = i - 1; j >= 0; j--) {
if (mp[b[j]]) continue;
if (b[j] == b[i]) break;
ans += w[b[j] - 1];
mp[b[j]]++;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[505], b[1005];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
memset(w, 0, sizeof(w));
memset(b, 0, sizeof(b));
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
bool flag[1005];
long long ans = 0;
for (int i = 2; i <= m; i++) {
memset(flag, 0, sizeof(flag));
for (int j = i - 1; j > 0; j--) {
if (b[i] == b[j]) break;
if (!flag[b[j]]) {
ans += w[b[j]];
flag[b[j]] = true;
}
}
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int lis;
struct node *link;
};
int n, m, i, j, sum, ans;
int readlist[1005], w[505], vis[505];
node *initial() {
node *head, *p1, *p2;
head = (node *)malloc(sizeof(node));
head->link = NULL;
head->lis = 0;
p1 = head;
for (int i = 1; i <= m; i++) {
cin >> readlist[i];
if (vis[readlist[i]] == 0) {
p2 = (node *)malloc(sizeof(node));
p2->lis = readlist[i];
p2->link = NULL;
p1->link = p2;
p1 = p2;
vis[readlist[i]] = 1;
}
}
return (head);
}
void append(node *head, int v) {
node *ptr;
ptr = (node *)malloc(sizeof(node));
ptr->lis = v;
ptr->link = head->link;
head->link = ptr;
}
void delet(node *pf) {
node *ptr;
ptr = pf->link;
if (ptr != NULL) {
pf->link = ptr->link;
free(ptr);
}
}
void search(node *head, int v) {
node *ptr;
ptr = (node *)malloc(sizeof(node));
ptr = head;
while (1) {
sum += w[ptr->lis];
if (ptr->link->lis == v) break;
ptr = ptr->link;
}
delet(ptr);
append(head, v);
}
void print(node *head) {
node *ptr;
ptr = (node *)malloc(sizeof(node));
ptr = head->link;
while (1) {
cout << ptr->lis << " ";
if (ptr->link == NULL) break;
ptr = ptr->link;
}
cout << endl;
}
int main() {
while (cin >> n >> m) {
memset(w, 0, sizeof(w));
memset(readlist, 0, sizeof(readlist));
memset(vis, 0, sizeof(vis));
sum = 0;
for (i = 1; i <= n; i++) cin >> w[i];
node *head;
head = initial();
for (i = 1; i <= m; i++) {
search(head, readlist[i]);
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[1005], b[1005];
bool vis[1005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &w[i]);
}
for (int j = 0; j < m; j++) {
scanf("%d", &b[j]);
}
memset(vis, false, sizeof(vis));
int ans = 0;
vector<int> s;
for (int i = m - 1; i >= 0; i--) {
if (!vis[b[i]]) {
vis[b[i]] = true;
s.push_back(b[i]);
} else {
vector<int>::iterator p = find(s.begin(), s.end(), b[i]);
s.erase(p);
s.push_back(b[i]);
}
}
for (int i = 0; i < m; i++) {
vector<int>::iterator p = find(s.begin(), s.end(), b[i]);
vector<int>::iterator it = p;
while (++it != s.end()) {
ans += w[*it - 1];
}
s.erase(p);
s.push_back(b[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[502];
int b[1002];
bool f[502];
int c[502];
int n, m;
int main() {
int i, j, k = 0, res = 0;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> w[i];
for (i = 0; i < m; i++) cin >> b[i];
for (i = 0; i < m; i++)
if (!f[b[i]]) {
f[b[i]] = true;
c[k++] = b[i];
}
for (i = 0; i < m; i++) {
for (j = 0; j < k; j++)
if (c[j] != b[i])
res += w[c[j]];
else
break;
for (; j > 0; j--) c[j] = c[j - 1];
c[0] = b[i];
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Read(T &t) {
int c = getchar(), f = 0;
for (; c < '0' || c > '9'; c = getchar()) f = (c == '-');
for (t = 0; c >= '0' && c <= '9'; c = getchar())
t = (t << 3) + (t << 1) + (c ^ 48);
if (f) t = -t;
}
int n, m, a[1003], b[1003], c[1003], ans;
int main() {
Read(n), Read(m);
for (register int i = 1; i <= n; ++i) Read(a[i]);
for (register int i = 1; i <= m; ++i) Read(c[i]);
for (register int i = 1; i <= m; ++i) {
memset(b, 0, sizeof(b));
for (register int j = i - 1; j; --j) {
if (c[i] == c[j]) break;
if (!b[c[j]]) b[c[j]] = 1, ans += a[c[j]];
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> w(n);
for (int i = 0; i < n; i++) cin >> w[i];
int x = 0;
vector<int> ord(n);
vector<int> rd(m);
vector<bool> put(n, false);
for (int i = 0; i < m; i++) {
cin >> rd[i];
rd[i]--;
if (put[rd[i]])
continue;
else {
ord[x] = rd[i];
put[rd[i]] = true;
x++;
}
}
for (int i = 0; i < n; i++) {
if (!put[i]) {
ord[x] = i;
x++;
}
}
int lift = 0;
for (int i = 0; i < m; i++) {
int in = 0;
for (int j = 0; j < n; j++) {
if (ord[j] == rd[i]) {
in = j;
}
}
for (int j = in; j > 0; j--) {
ord[j] = ord[j - 1];
lift += w[ord[j]];
}
ord[0] = rd[i];
}
cout << lift << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long n) {
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return false;
}
return true;
}
bool prm[10000007];
long long N = 10000000;
void sieve() {
prm[1] = 1;
for (long long i = 2; i <= sqrt(N); i++) {
if (prm[i] == 0) {
for (long long j = i + i; j <= N; j = j + i) prm[j] = 1;
}
}
}
long long bm(long long b, long long p) {
long long namira;
if (p == 0) return 1;
if (p % 2 == 0) {
namira = bm(b, p / 2);
return ((namira % 1000000007) * (namira % 1000000007)) % 1000000007;
} else {
return ((b % 1000000007) * (bm(b, p - 1) % 1000000007)) % 1000000007;
}
}
int main() {
long long i, n, m, c, p, x, a[510], A[510], b[1010], k, j;
scanf("%I64d%I64d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
scanf("%I64d", &b[0]);
k = 1;
for (i = 1; i < m; i++) {
scanf("%I64d", &x);
if (x != b[k - 1]) {
b[k] = x;
k++;
}
}
c = 0;
for (i = 1; i < k; i++) {
for (j = 1; j <= n; j++) A[j] = 1;
for (j = i - 1; j >= 0; j--) {
if (b[i] == b[j]) {
break;
} else {
if (A[b[j]] != 0) {
A[b[j]] = 0;
c += a[b[j]];
}
}
}
}
printf("%I64d\n", c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[505], b[1005];
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = -1;
}
long long sum = 0;
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
for (int j = 1; j <= n; j++) {
if (b[j] > b[x]) sum += a[j];
}
b[x] = i;
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m, i;
cin >> n >> m;
long long int a[n], b[m];
map<long long int, long long int> ma;
for (i = 0; i < n; i++) cin >> a[i];
vector<long long int> v;
for (i = 0; i < m; i++) {
cin >> b[i];
if (ma[b[i]] == 0) {
ma[b[i]] = 1;
v.push_back(b[i]);
}
}
long long int ans = 0;
for (i = 0; i < m; i++) {
long long int x = 0;
while (v[x] != b[i]) {
ans += a[v[x] - 1];
x++;
}
v.erase(v.begin() + x);
v.insert(v.begin(), b[i]);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2001;
const int MAXN = 30001;
const int logn = 12;
const int inf = (int)1e9;
const int alpha = 26;
const int my_hash = 31;
const long long base = (long long)1e9;
const long long my_mod = 2674894331;
const long long l_inf = (long long)4e18;
const long long mod = (long long)1e9 + 7;
const long long l_mod = (long long)1e18 - 11;
const double fi = (sqrt(5.0) + 1) / 2.0;
const double pi = acos(-1.0);
const double eps = 1e-8;
const double EPS = 0.00005;
int main() {
ios_base::sync_with_stdio(0);
int n, m, ans = 0;
scanf("%d %d ", &n, &m);
vector<int> w(n), cnt(n), list;
for (int i = 0; i < n; i++) scanf("%d ", &w[i]);
for (int i = 0; i < m; i++) {
int book;
scanf("%d ", &book);
book--;
int pos = -1;
for (int j = 0; j < int(list.size()); j++)
if (list[j] == book) pos = j;
if (pos == -1) {
for (int j = 0; j < int(list.size()); j++) cnt[list[j]]++;
list.push_back(book);
} else {
for (int j = pos; j + 1 < int(list.size()); j++) {
cnt[list[j + 1]]++;
swap(list[j], list[j + 1]);
}
}
}
for (int i = 0; i < n; i++) ans += cnt[i] * w[i];
printf("%d", ans);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
void get_val(int &a) {
int value = 0, s = 1;
char c;
while ((c = getchar()) == ' ' || c == '\n')
;
if (c == '-')
s = -s;
else
value = c - 48;
while ((c = getchar()) >= '0' && c <= '9') value = value * 10 + c - 48;
a = s * value;
}
int mat[350][350] = {0};
int numbre[350];
int vis[350] = {0};
void dfs(int now, int n) {
for (int i = 1; i <= n; i++) {
if (!vis[i] && mat[now][i]) {
vis[i] = 1;
dfs(i, n);
for (int j = 1; j <= n; j++)
mat[now][j] = mat[i][j] = (mat[now][j] | mat[i][j]);
}
}
}
int w[1000], order[1500], ans_o[1500];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= m; i++) cin >> order[i];
int ans = 0, len = 1;
for (int i = 1; i <= m; i++) {
if (order[i] == order[i - 1] && i != 1) continue;
int j, tmp = 0;
for (j = 1; j < len; j++) {
if (ans_o[j] == order[i]) break;
tmp += w[ans_o[j]];
}
ans += tmp;
ans_o[0] = order[i];
if (j >= len) len++;
for (int i = j; i >= 1; i--) ans_o[i] = ans_o[i - 1];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> w(n);
for (int i = 0; i < n; i++) {
cin >> w[i];
}
vector<bool> arr(n, false);
deque<int> q;
vector<int> order;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
order.push_back(x);
if (!arr[x - 1]) {
q.push_back(x);
arr[x - 1] = true;
}
}
stack<int> st;
int ans = 0;
for (int i = 0; i < m; i++) {
while (q.front() != order[i]) {
ans += w[q.front() - 1];
st.push(q.front());
q.pop_front();
}
q.pop_front();
while (!st.empty()) {
q.push_front(st.top());
st.pop();
}
q.push_front(order[i]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
long long ans;
bool used[N + 10];
int n, m, cnt, w[N + 10], b[N + 10], c[N + 10], book[N + 10];
struct node {
int x, y, z;
node() {}
node(int _x, int _y, int _z) : x(_x), y(_y), z(_z) {}
} a[N + 10];
inline bool cmp(const node &a, const node &b) { return a.x * a.y > b.x * b.y; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
for (int i = 1; i <= m; ++i) scanf("%d", &b[i]), c[b[i]]++;
for (int i = 1; i <= n; ++i) a[i] = node(c[i], w[i], i);
for (int i = 1; i <= m; ++i)
if (!used[b[i]]) book[++cnt] = b[i], used[b[i]] = 1;
for (int i = 1; i <= m; ++i) {
int j;
for (j = 1;; ++j) {
if (book[j] == b[i]) break;
ans += w[book[j]];
}
for (int k = j - 1; k >= 1; --k) book[k + 1] = book[k];
book[1] = b[i];
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int w[510], b[1010], c[510], d[510];
int main(void) {
int i, j, k, n, m;
while (scanf("%d%d", &n, &m) != EOF) {
k = 1;
long long ans = 0;
memset(c, 0, sizeof(c));
for (i = 1; i <= n; i++) scanf("%d", &w[i]);
for (i = 1; i <= m; i++) {
scanf("%d", &b[i]);
if (c[b[i]] == 0) {
d[k++] = b[i];
c[b[i]] = 1;
}
}
for (i = 1; i <= m; i++) {
j = 1;
while (d[j] != b[i]) ans += w[d[j++]];
while (j > 1) {
d[j] = d[j - 1];
j--;
}
d[1] = b[i];
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[1010];
int b[1010];
int vis[1010];
int main() {
ios::sync_with_stdio(false);
int n, m;
while (cin >> n >> m) {
for (int i = 1; i <= n; i++) {
cin >> w[i];
}
for (int j = 0; j < m; j++) {
cin >> b[j];
}
stack<int> s1;
stack<int> s2;
long long ans = 0;
long long tmp;
memset(vis, 0, sizeof(vis));
long long sum = 0;
int d;
for (int i = 0; i < m; i++) {
if (!vis[b[i]]) {
ans += (long long)sum;
s1.push(b[i]);
sum += (long long)w[b[i]];
vis[b[i]] = 1;
} else {
tmp = 0;
while (s1.top() != b[i]) {
s2.push(s1.top());
s1.pop();
tmp += w[s2.top()];
}
d = s1.top();
s1.pop();
while (!s2.empty()) {
s1.push(s2.top());
s2.pop();
}
s1.push(d);
ans += tmp;
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[555], b[1111];
bool vis[555];
int main() {
int n, m;
while (scanf("%d %d", &n, &m) != EOF) {
int i, j;
for (i = 1; i <= n; i++) scanf("%d", &w[i]);
for (j = 1; j <= m; j++) scanf("%d", &b[j]);
int ans = 0;
for (i = 2; i <= m; i++) {
memset(vis, false, sizeof(vis));
for (j = i - 1; j > 0; j--) {
if (b[i] == b[j]) break;
if (!vis[b[j]]) {
ans += w[b[j]];
vis[b[j]] = true;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const bool ready = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
return true;
}();
const double PI = acos(-1);
using ll = long long;
using pii = pair<ll, ll>;
using pdd = pair<double, double>;
using vd = vector<double>;
using vb = vector<bool>;
using vi = vector<ll>;
using vvi = vector<vi>;
using vs = vector<string>;
template <typename E>
class SegmentTree {
private:
vector<E> tree;
E neutral;
function<E(E, E)> cumul;
ll treeDataOffset;
const ll ROOT = 1;
inline ll leftChild(const ll treeIdx) { return treeIdx * 2; }
inline ll rightChild(const ll treeIdx) { return treeIdx * 2 + 1; }
inline ll parent(const ll treeIdx) { return treeIdx / 2; }
inline bool isOdd(const ll idx) { return (idx & 0x1); }
public:
template <typename Iterator>
SegmentTree(Iterator beg, Iterator end, E pNeutral,
function<E(E, E)> pCumul) {
neutral = pNeutral;
cumul = pCumul;
treeDataOffset = (ll)distance(beg, end);
tree = vector<E>(treeDataOffset * 2, pNeutral);
ll i = treeDataOffset;
for (auto it = beg; it != end; it++) tree[i++] = *it;
for (ll j = treeDataOffset - 1; j >= 1; j--)
tree[j] = cumul(tree[leftChild(j)], tree[rightChild(j)]);
}
void updateRange(ll pIdxL, ll pIdxR, function<E(E)> apply) {
pIdxL += treeDataOffset;
pIdxR += treeDataOffset;
for (ll i = pIdxL; i < pIdxR; i++) tree[i] = apply(tree[i]);
while (pIdxL != ROOT) {
pIdxL = parent(pIdxL);
pIdxR = max(pIdxL, parent(pIdxR - 1));
for (ll i = pIdxL; i <= pIdxR; i++)
tree[i] = cumul(tree[leftChild(i)], tree[rightChild(i)]);
}
}
void updateApply(ll dataIdx, function<E(E)> apply) {
updateSet(dataIdx, apply(get(dataIdx)));
}
void updateSet(ll dataIdx, E value) {
ll treeIdx = treeDataOffset + dataIdx;
tree[treeIdx] = value;
while (treeIdx != ROOT) {
treeIdx = parent(treeIdx);
tree[treeIdx] =
cumul(tree[leftChild(treeIdx)], tree[rightChild(treeIdx)]);
}
}
E get(ll idx) { return tree[idx + treeDataOffset]; }
E get(ll pIdxL, ll pIdxR) {
ll idxL = pIdxL + treeDataOffset;
ll idxR = pIdxR + treeDataOffset;
E cum = neutral;
while (idxL < idxR) {
if (isOdd(idxL)) {
cum = cumul(cum, tree[idxL]);
idxL++;
}
if (isOdd(idxR)) {
idxR--;
cum = cumul(cum, tree[idxR]);
}
idxL = parent(idxL);
idxR = parent(idxR);
}
return cum;
}
};
void solve() {
ll n;
cin >> n;
;
ll m;
cin >> m;
;
vi w(n);
for (ll i = 0; i < ll(n); i++) {
cin >> w[i];
};
vb vis(n);
vi data(m);
vi pos(n);
vi r(m);
for (ll i = 0; i < ll(m); i++) {
cin >> r[i];
};
for (ll i = 0; i < m; i++) {
cin >> r[i];
r[i]--;
if (!vis[r[i]]) {
vis[r[i]] = true;
data.push_back(w[r[i]]);
pos[r[i]] = data.size() - 1;
}
}
SegmentTree<ll> seg(data.begin(), data.end(), 0,
[](ll i1, ll i2) { return i1 + i2; });
ll top = m - 1;
ll ans = 0;
for (ll i = 0; i < m; i++) {
ans += seg.get(0, pos[r[i]]);
seg.updateSet(top, w[r[i]]);
seg.updateSet(pos[r[i]], 0);
pos[r[i]] = top;
top--;
}
cout << ans << endl;
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int days[1005], w[505];
vector<int> v;
stack<int> st;
int main() {
ios_base::sync_with_stdio(false);
int n, m, i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> w[i];
for (i = 0; i < m; i++) cin >> days[i];
int ans = 0;
for (i = 0; i < m; i++) {
v.clear();
int sum = 0;
bool flag = false;
while (!st.empty()) {
int t = st.top();
st.pop();
if (t != days[i]) {
sum += w[t];
v.push_back(t);
}
if (t == days[i]) {
flag = true;
break;
}
}
for (j = v.size() - 1; j >= 0; j--) st.push(v[j]);
st.push(days[i]);
ans += sum;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<int> weights;
for (int i = 0; i < n; i++) {
int n;
cin >> n;
weights.push_back(n);
}
vector<int> days;
for (int i = 0; i < m; i++) {
int m;
cin >> m;
days.push_back(m);
}
list<int> bookOrder;
set<int> seenBooks;
for (int i : days) {
if (!seenBooks.count(i)) {
seenBooks.insert(i);
bookOrder.push_back(i);
}
}
int totalWeight = 0;
for (int i : days) {
auto it = bookOrder.begin();
while (*it != i) {
totalWeight += weights[*it - 1];
it++;
}
bookOrder.erase(it);
bookOrder.push_front(i);
}
cout << totalWeight << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int weight[n + 1];
int stacked[m + 1];
for (int i = 1; i <= n; i++) {
cin >> weight[i];
}
for (int i = 1; i <= m; i++) {
cin >> stacked[i];
}
bool vis[n + 1];
memset(vis, false, sizeof(vis));
int ans = 0;
for (int i = 2; i <= m; i++) {
memset(vis, false, sizeof(vis));
for (int j = i - 1; j >= 1; j--) {
if (stacked[j] == stacked[i]) break;
if (!vis[stacked[j]]) {
ans += weight[stacked[j]];
vis[stacked[j]] = true;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
int stack1[505], stack2[505], w[505];
int main() {
int n, m, cnt1 = 0, cnt2 = 0;
scanf("%d %d", &n, &m);
int ans = 0;
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 0; i < m; i++) {
int a;
scanf("%d", &a);
for (; cnt1; cnt1--) {
if (stack1[cnt1 - 1] != a) {
ans += w[stack1[cnt1 - 1]];
stack2[cnt2++] = stack1[cnt1 - 1];
} else {
cnt1--;
break;
}
}
while (cnt2) {
stack1[cnt1++] = stack2[cnt2 - 1];
cnt2--;
}
stack1[cnt1++] = a;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
stack<int> act, temp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k, cur;
cin >> n >> m;
int i, w[505], a[1005], b[505], c[505];
for (i = 1; i <= n; i++) cin >> w[i];
int j = 1;
memset(b, 0, sizeof(b));
k = 1;
for (i = 1; i <= m; i++) {
cin >> a[i];
if (b[a[i]] == 0) {
b[a[i]] = 1;
c[k++] = a[i];
}
}
for (j = k - 1; j >= 1; j--) act.push(c[j]);
int s, sum = 0;
for (i = 1; i <= m; i++) {
while (act.top() != a[i]) {
temp.push(act.top());
act.pop();
}
cur = act.top();
act.pop();
s = 0;
while (!temp.empty()) {
act.push(temp.top());
s += w[temp.top()];
temp.pop();
}
act.push(cur);
sum += s;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000], b[2000], last[1001];
bool v[501];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 0; i < m; ++i) cin >> b[i];
for (int i = 0; i < n; ++i) last[i] = 0;
int ans = 0;
for (int i = 0; i < m; ++i) {
memset(v, 0, sizeof v);
for (int j = last[b[i]]; j < i; ++j)
if (!v[b[j]]) {
ans += a[b[j]];
v[b[j]] = true;
}
last[b[i]] = i + 1;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[510], n, m;
int tot;
stack<int> s;
int use[510];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
int t;
for (int i = 0; i < m; i++) {
scanf("%d", &t);
stack<int> tmp;
while (!tmp.empty()) tmp.pop();
if (use[t] == 0) {
while (!s.empty()) {
int x = s.top();
s.pop();
tot += a[x];
tmp.push(x);
}
use[t] = 1;
while (!tmp.empty()) {
int x = tmp.top();
tmp.pop();
s.push(x);
}
s.push(t);
} else {
while (!s.empty()) {
int x = s.top();
s.pop();
if (x != t) {
tmp.push(x);
tot += a[x];
} else
break;
}
while (!tmp.empty()) {
int x = tmp.top();
tmp.pop();
s.push(x);
}
s.push(t);
}
}
cout << tot << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000100;
const int mod = 1000000009;
int w[510], b[1010], us[510];
vector<int> v;
int main() {
int n, m, i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> w[i];
for (j = 1; j <= m; j++) {
cin >> b[j];
if (!us[b[j]]) {
v.push_back(b[j]);
us[b[j]] = 1;
}
}
for (i = 1; i <= n; i++)
if (!us[i]) {
v.push_back(i);
us[i] = 1;
}
int ans = 0;
for (j = 1; j <= m; j++) {
for (i = 0; i < v.size(); i++) {
if (v[i] == b[j]) break;
ans += w[v[i]];
}
while (i > 0) v[i] = v[i - 1], i--;
v[0] = b[j];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, sum = 0;
scanf("%d%d", &n, &m);
int a[n], c[m], h[n + 1], s[n], i, j = 0, l, k;
memset(h, 0, sizeof(h));
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &c[i]);
if (h[c[i]] == 0) {
s[j] = c[i];
j++;
h[c[i]]++;
}
}
l = j;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (s[j] == c[i]) {
l = s[j];
for (k = j; k >= 1; k--) {
s[k] = s[k - 1];
}
s[0] = l;
break;
} else {
sum += a[s[j] - 1];
}
}
}
printf("%d", sum);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int kn[1100];
int dni[1100];
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", (kn + i));
}
for (int i = 1; i <= m; i++) {
scanf("%d", (dni + i));
}
int s = 0;
for (int i = 1; i <= m; i++) {
int sh = 0;
int verx[1100];
for (int i = 0; i < 1100; i++) {
verx[i] = 0;
}
int j = i - 1;
for (;;) {
if (j == 0) {
break;
}
if (dni[j] == dni[i]) {
break;
}
verx[dni[j]] = 1;
j--;
}
for (int i = 0; i < 1100; i++) {
if (verx[i] == 1) {
sh += kn[i];
}
}
s += sh;
}
printf("%d", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1010];
int v[1010];
int vis[1010];
int main(void) {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 0; i < m; ++i) {
cin >> v[i];
}
int ac = 0;
for (int i = 0; i < m; ++i) {
memset(vis, 0, sizeof vis);
for (int j = i - 1; j >= 0; --j) {
if (v[i] == v[j]) {
break;
} else if (!vis[v[j]]) {
vis[v[j]] = 1;
ac += a[v[j]];
}
}
}
cout << ac << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e3 + 3;
int n, m, w[Maxn], num[Maxn], d[Maxn];
bool mark[Maxn];
void PRE();
int GO(int q);
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = (int)(0); i < (int)(n); ++i) cin >> w[i];
for (int i = (int)(0); i < (int)(m); ++i) {
cin >> d[i];
--d[i];
}
PRE();
int ans = 0;
for (int i = (int)(0); i < (int)(m); ++i) ans += GO(d[i]);
cout << ans << endl;
return 0;
}
void PRE() {
int cnt = 0;
for (int i = (int)(0); i < (int)(m); ++i)
if (!mark[d[i]]) {
mark[d[i]] = 1;
num[cnt++] = d[i];
}
for (int i = (int)(0); i < (int)(n); ++i)
if (!mark[i]) num[cnt++] = i;
}
int GO(int q) {
int p = 0;
for (int i = (int)(0); i < (int)(n); ++i)
if (num[i] == q) p = i;
int ans = 0;
for (int i = p - 1; i >= 0; --i) ans += w[num[i]], swap(num[i], num[i + 1]);
return ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 510;
const int MAXM = 1010;
int n, m;
int w[MAXN], b[MAXM];
int v[MAXN];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= m; i++) cin >> b[i];
int sum, ans;
sum = ans = 0;
for (int i = 1; i <= m; i++) {
sum = 0;
memset(v, 0, sizeof(v));
for (int j = i - 1; j > 0 && b[j] != b[i]; j--)
if (v[b[j]] == 0) {
sum += w[b[j]];
v[b[j]] = 1;
}
ans += sum;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double EPS = 0.000000001;
const double PI = 3.141592653589793;
const long long LLINF = 99999999999999999LL;
const int MAX_N = 1005;
const int MOD = 1000000007;
int N, M;
int v[MAX_N], w[MAX_N], a[MAX_N];
int main() {
cin >> N >> M;
for (int i = 1; i <= N; ++i) cin >> w[i];
for (int i = 1; i <= M; ++i) cin >> v[i];
int ans = 0;
for (int i = 1; i <= M; ++i) {
memset(a, 0, sizeof(a));
for (int j = i - 1; j >= 1; --j) {
if (v[j] == v[i]) break;
if (a[v[j]] == 0) a[v[j]] = 1, ans += w[v[j]];
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int n, m, w[501], b[1000], d[1000], e[1001], ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", w + i);
for (int i = 0; i < m; i++) {
scanf("%d", b + i);
for (int j = i - 1; j >= 0 && b[j] != b[i]; j--) e[b[j]] = 1;
for (int j = 1; j <= n; j++)
if (e[j]) ans += w[j], e[j] = 0;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
for (int(i) = 0; (i) < (t.size()); ++(i)) {
os << t[i] << ",";
}
os << "}" << endl;
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(0);
int i, j, k;
int n, m;
cin >> n >> m;
vector<long long> w(n), b(m), sum(n), stk;
long long re = 0;
for (int(i) = 0; (i) < (n); ++(i)) cin >> w[i];
for (int(i) = 0; (i) < (m); ++(i)) cin >> b[i];
for (int(i) = 0; (i) < (m); ++(i)) {
b[i]--;
if (count((stk).begin(), (stk).end(), b[i]) == 0) stk.push_back(b[i]);
}
for (int(i) = 0; (i) < (m); ++(i)) {
for (int(j) = 0; (j) < (stk.size()); ++(j)) {
if (stk[j] == b[i]) {
stk.erase(stk.begin() + j);
break;
}
re += w[stk[j]];
}
stk.insert(stk.begin(), b[i]);
}
cout << re << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1000 + 100;
long long w[MAXN], arr[MAXN];
long long javab[MAXN];
bool mrk[MAXN];
int32_t main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> w[i];
for (long long i = 0; i < m; i++) {
cin >> arr[i];
arr[i]--;
}
for (long long i = 0; i < MAXN; i++) javab[i] = -1;
long long pt = 0;
long long cnt = 0;
for (long long i = 0; i < m; i++) {
for (long long i = 0; i < n; i++) mrk[i] = 0;
bool h = 0;
for (long long j = pt - 1; j >= 0; j--)
if (javab[j] == arr[i]) {
h = 1;
for (long long k = 0; k < n; k++)
if (mrk[k]) cnt += w[k];
break;
} else
mrk[javab[j]] = 1;
javab[pt++] = arr[i];
if (!h)
for (long long k = 0; k < n; k++)
if (mrk[k]) cnt += w[k];
}
cout << cnt << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans = 0;
int w[510];
int vis[510];
int d[1010];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", &w[i]);
}
for (int i = 0; i < m; ++i) {
scanf("%d", &d[i]);
d[i]--;
memset(vis, 0, sizeof vis);
for (int j = i - 1; j >= 0; --j) {
if (d[i] == d[j]) break;
if (!vis[d[j]]) {
vis[d[j]] = 1;
ans += w[d[j]];
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans;
int w[1010], b[1010];
int Q[1010];
int p;
bool vis[1010];
vector<int> seq;
void inline init() {
memset(w, 0, sizeof(w));
memset(b, 0, sizeof(b));
seq.clear();
memset(vis, 0, sizeof(vis));
ans = 0;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
init();
for (int i = 1; i <= n; i++) scanf("%d", w + i);
for (int i = 1; i <= m; i++) {
scanf("%d", b + i);
if (!vis[i]) {
seq.push_back(b[i]);
vis[i] = true;
}
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= m; i++) {
for (int j = i - 1; j >= 1; j--) {
if (b[j] == b[i]) break;
if (!vis[b[j]]) {
ans += w[b[j]];
vis[b[j]] = true;
}
}
memset(vis, 0, sizeof(vis));
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 10000 + 17;
int n, m, w[N], b[N], T[N], j[N], sum[N], ans;
vector<int> id, Q;
bool vis[N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < m; i++) {
cin >> b[i];
b[i]--;
}
for (int i = 0; i < m; i++)
if (!vis[b[i]]) {
Q.push_back(b[i]);
vis[b[i]] = 1;
}
for (int i = 0; i < m; i++) {
int cnt = 0;
while (Q[cnt] != b[i]) {
ans += w[Q[cnt]];
cnt++;
}
for (int i = cnt; i > 0; i--) Q[i] = Q[i - 1];
Q[0] = b[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[550], b[550], c[550];
bool vis[550];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
stack<int> f, s;
int x, ans = 0;
for (int i = 0; i < m; i++) {
cin >> x;
int res = 0;
while (!f.empty()) {
s.push(f.top());
f.pop();
if (s.top() == x) {
s.pop();
break;
}
res += a[s.top()];
}
ans += res;
while (!s.empty()) {
f.push(s.top());
s.pop();
}
f.push(x);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[510], b[1010], i, n, m, sm, x, j;
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> a[i];
b[i] = -1;
}
for (i = 1; i <= m; i++) {
cin >> x;
for (j = 1; j <= n; j++)
if (b[j] > b[x]) {
sm += a[j];
}
b[x] = i;
}
cout << sm;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, l;
bool used[500 + 10];
vector<int> books, order, weight;
int readBook(int x) {
int w = 0;
for (int i = find(books.begin(), books.end(), x) - books.begin(); i >= 1;
i--) {
books[i] = books[i - 1];
w += weight[books[i]];
}
books[0] = x;
return w;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> l;
weight.push_back(l);
}
for (int i = 0; i < m; i++) {
cin >> l;
l--;
if (!used[l]) {
books.push_back(l);
used[l] = true;
}
order.push_back(l);
}
int ans = 0;
for (int i = 0; i < order.size(); i++) {
ans += readBook(order[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int b[1001];
int arr[1001];
bool vis[1001];
int main() {
int tc, cs = 1, i, j, k;
int n, m;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> arr[i];
for (i = 1; i <= m; i++) {
cin >> b[i];
}
int res = 0;
for (i = 1; i <= m; i++) {
memset(vis, false, sizeof vis);
for (j = i - 1; j >= 1; j--) {
if (b[j] == b[i]) break;
if (vis[b[j]]) continue;
vis[b[j]] = true;
res += arr[b[j]];
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, sum;
int w[1009], b[1009], read[1009];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 1; i <= m; i++) {
memset(read, 0, sizeof(read));
for (int j = i - 1; j >= 0; j--) {
if (b[i] == b[j]) break;
if (read[b[j]] == 0) {
read[b[j]] = 1, sum += w[b[j]];
}
}
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
deque<int> fuck;
int wight[505];
int day[1005];
bool vis[1005];
int main() {
int n, k;
int sum = 0;
cin >> n >> k;
memset(vis, false, sizeof(vis));
for (int i = 1; i <= n; i++) {
scanf("%d", &wight[i]);
}
for (int i = 1; i <= k; i++) {
scanf("%d", &day[i]);
}
for (int i = 1; i <= n; i++) {
if (!vis[day[i]]) {
fuck.push_back(day[i]);
vis[day[i]] = true;
}
}
for (int i = 1; i <= k; i++) {
int num = day[i];
int pos = 0;
int temp;
for (auto it = fuck.begin(); it != fuck.end(); ++it) {
if (*it == num) {
fuck.erase(it);
break;
}
sum = sum + wight[*it];
}
fuck.push_front(num);
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int change(int day, int len, int s[], int pos, int we[]);
int n, day, we[1000], book[1000], res = 0, s[1000], len = 1;
int main() {
cin >> n >> day;
for (int i = 0; i < n; i++) cin >> we[i];
for (int i = 0; i < day; i++) cin >> book[i];
s[0] = book[0];
for (int i = 1; i < day; i++) {
int check = 0;
for (int j = 0; j < len; j++)
if (s[j] == book[i]) {
check = 1;
break;
}
if (!check) s[len++] = book[i];
}
for (int i = 1; i < day; i++) res += change(day, len, s, book[i], we);
cout << res;
return 0;
}
int change(int day, int len, int s[], int pos, int we[]) {
int sum = 0, tmp[500], lens = 1;
tmp[0] = pos;
for (int i = 0; s[i] != pos; i++) {
sum += we[s[i] - 1];
tmp[lens++] = s[i];
}
for (int i = 0; i < lens; i++) s[i] = tmp[i];
return sum;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 505;
int w[MAXN], q[MAXN];
int main() {
int n, m, b, tot = 0, ans = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
while (m--) {
scanf("%d", &b);
int idx;
for (idx = 0; idx < tot; ++idx)
if (q[idx] == b) break;
if (idx < tot) {
for (++idx; idx < tot; ++idx) {
ans += w[q[idx]];
swap(q[idx], q[idx - 1]);
}
} else {
for (int i = 0; i < tot; ++i) ans += w[q[i]];
q[tot++] = b;
}
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> w(n);
for (int i = 0; i < n; i++) cin >> w[i];
vector<int> b(m);
for (int i = 0; i < m; i++) {
cin >> b[i];
b[i]--;
}
long long res = 0;
for (int i = 0; i < m; i++) {
bool visited[n];
for (int j = 0; j < n; j++) visited[j] = false;
for (int j = i - 1; j >= 0; j--) {
if (b[i] == b[j]) break;
if (!visited[b[j]]) {
res += w[b[j]];
visited[b[j]] = true;
}
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
int n, m, w[1234], b, ans, cur[1234], csz;
char s[1234];
int main() {
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); i++) scanf("%d", w + i);
for (int i = (0); i < (m); i++) {
scanf("%d", &b);
b--;
if (!s[b]) {
for (int j = (0); j < (csz); j++) ans += w[cur[j]];
for (int j = csz; j >= 0; j--) cur[j + 1] = cur[j];
cur[0] = b;
csz++;
} else {
int pos = 0;
for (int j = (0); j < (csz); j++)
if (cur[j] == b) pos = j;
for (int j = (0); j < (pos); j++) ans += w[cur[j]];
for (int j = pos - 1; j >= 0; j--) cur[j + 1] = cur[j];
cur[0] = b;
}
s[b] = 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int stk[505];
int n, m;
int w[505];
int b[1005];
bool placed[505];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", w + i);
}
int stkcur = 1;
for (int i = 1; i <= m; i++) {
scanf("%d", b + i);
if (!placed[b[i]]) {
stk[stkcur] = b[i];
stkcur++;
placed[b[i]] = true;
}
}
int ans = 0;
for (int i = 1; i <= m; i++) {
int j;
for (j = 1; j <= n; j++) {
if (stk[j] == b[i]) break;
ans += w[stk[j]];
}
for (int k = j; k >= 2; k--) {
stk[k] = stk[k - 1];
}
stk[1] = b[i];
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, i, j, k, ans = 0;
cin >> n >> m;
vector<int> w(n + 1), b(m + 1), last(n + 1, 0), touch(n + 1, 0);
for (i = 1; i <= n; i++) cin >> w[i];
for (i = 1; i <= m; i++) cin >> b[i];
ans = 0;
for (i = 1; i <= m; i++) {
for (j = last[b[i]] + 1; j < i; j++) {
if (touch[b[j]] < i) {
touch[b[j]] = i;
ans += w[b[j]];
}
}
last[b[i]] = i;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MAXN = 2e5 + 5;
const long long INF = 1e18;
const long double PI = acos((long double)-1);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, w, b;
cin >> n >> m;
vector<long long> weights, read;
deque<long long> order;
weights.push_back(0);
for (int i = (1); i <= (n); i++) {
cin >> w;
weights.push_back(w);
}
bool check[505];
read.push_back(0);
memset(check, 0, sizeof(check));
for (int i = (1); i <= (m); i++) {
cin >> b;
read.push_back(b);
if (!check[b]) {
check[b] = 1;
order.push_back(b);
}
}
long long ans = 0;
for (int i = (1); i <= (m); i++) {
long long toread = read[i];
long long sum = 0;
for (auto it = order.begin(); it != order.end(); it++) {
if (*it == toread) {
ans += sum;
order.erase(it);
order.push_front(toread);
break;
} else {
sum += weights[*it];
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100000];
int w[100000];
int b[100000];
int main() {
int t;
t = 1;
while (t--) {
int n;
int m;
scanf("%d", &(n));
scanf("%d", &(m));
for (int i = 1; i <= n; i++) scanf("%d", &(w[i]));
for (int i = 1; i <= m; i++) scanf("%d", &(a[i]));
int ans = 0;
int l = 1;
for (int i = 1; i <= m; i++) {
int j;
for (j = l - 1; j > 0 && b[j] != a[i]; j--) ans += w[b[j]];
if (j == 0) {
b[l] = a[i];
l++;
} else {
while ((j + 1) < l) {
b[j] = b[j + 1];
j++;
}
b[j] = a[i];
}
}
printf("%d", (ans));
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
int w[maxn], k[maxn];
vector<int> pos;
bool vis[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> w[i];
}
long long int ans = 0;
for (int i = 1; i <= m; i++) {
cin >> k[i];
if (!vis[k[i]]) {
pos.push_back(k[i]);
vis[k[i]] = 1;
}
}
for (int i = 1; i <= m; i++) {
int j = 0;
while (j < pos.size()) {
if (pos[j] == k[i]) {
pos.erase(pos.begin() + j);
break;
}
ans += w[pos[j]];
j++;
}
reverse(pos.begin(), pos.end());
pos.push_back(k[i]);
reverse(pos.begin(), pos.end());
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int N = 1005;
struct nodo {
int sum;
};
int n, m;
bool used[N];
int w[N];
int s[2 * N];
vector<int> libros;
nodo st[8 * N];
nodo NIL;
nodo merge(nodo a, nodo b) {
nodo q;
q.sum = a.sum + b.sum;
return q;
}
void build(int pos = 1, int l = 0, int r = N + n - 1) {
if (l == r) {
st[pos].sum = w[s[l]];
return;
}
int mi = (l + r) / 2;
build(2 * pos, l, mi);
build(2 * pos + 1, mi + 1, r);
st[pos] = merge(st[2 * pos], st[2 * pos + 1]);
}
void update(int x, int y, int pos = 1, int l = 0, int r = N + n - 1) {
if (l == r) {
st[pos].sum = y;
return;
}
int mi = (l + r) / 2;
if (l <= x && x <= mi)
update(x, y, 2 * pos, l, mi);
else
update(x, y, 2 * pos + 1, mi + 1, r);
st[pos] = merge(st[2 * pos], st[2 * pos + 1]);
}
nodo queryn(int x, int y, int pos = 1, int l = 0, int r = N + n - 1) {
if (y < l || r < x) return NIL;
if (x <= l && r <= y) return st[pos];
int mi = (l + r) / 2;
nodo L = queryn(x, y, 2 * pos, l, mi);
nodo R = queryn(x, y, 2 * pos + 1, mi + 1, r);
return merge(L, R);
}
int query(int x, int y) {
nodo ans = queryn(x, y);
return ans.sum;
}
int solve() {
int c = 0;
for (int i = 0; i < libros.size(); i++) {
for (int j = N - i; j < N + n; j++) {
if (s[j] == libros[i]) {
c += query(0, j - 1);
s[N - i - 1] = s[j];
s[j] = 0;
update(j, 0);
update(N - i - 1, w[libros[i]]);
}
}
}
return c;
}
int main() {
NIL.sum = 0;
int b;
int pos = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
while (m--) {
cin >> b;
libros.push_back(b);
if (!used[b]) {
s[N + pos++] = b;
used[b] = true;
}
}
for (int i = pos; i < n; i++) {
bool can = false;
for (int j = 1; j <= n && !can; j++) {
if (!used[j]) {
s[N + i] = j;
used[j] = true;
can = true;
}
}
}
build();
int ans = solve();
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[504], p[1004];
vector<int> v;
int main() {
int t, n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
set<int> st;
for (int i = 1; i <= m; i++) {
scanf("%d", &p[i]);
if (!st.count(p[i])) v.push_back(p[i]);
st.insert(p[i]);
}
reverse(v.begin(), v.end());
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < v.size(); j++)
if (v[j] == p[i]) {
for (int k = j + 1; k < v.size(); k++) ans += x[v[k]];
v.erase(v.begin() + j);
v.push_back(p[i]);
break;
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
bool Z[505];
int A[505], B[505], E[505], hay = 0, ctos, dias, cual, res = 0, suma = 0;
int main() {
scanf("%d%d", &ctos, &dias);
for (int i = 1; i <= ctos; i++) {
scanf("%d", &A[i]);
}
for (int i = 1; i <= dias; i++) {
scanf("%d", &cual);
if (!Z[cual]) {
Z[cual] = true;
res += suma;
++hay;
B[hay] = cual;
suma += A[cual];
E[cual] = hay;
} else {
for (int e = E[cual]; e < hay; e++) {
E[B[e + 1]] = e;
res += A[B[e + 1]];
B[e] = B[e + 1];
}
E[cual] = hay;
B[hay] = cual;
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<int> w(n);
for (int i = 0; i < n; ++i) cin >> w[i];
vector<int> b(m);
for (int i = 0; i < m; ++i) cin >> b[i];
for (int i = 0; i < m; ++i) --b[i];
vector<int> used(n);
vector<int> a;
for (int i = 0; i < m; ++i) {
if (used[b[i]]) continue;
used[b[i]] = 1;
a.push_back(b[i]);
}
int res = 0;
for (int i = 0; i < m; ++i) {
int j;
int ans = 0;
for (j = 0; j < a.size(); ++j)
if (a[j] == b[i])
break;
else
ans += w[a[j]];
res += ans;
int t = a[j];
for (int k = j; k > 0; --k) a[k] = a[k - 1];
a[0] = t;
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[512], b[512], n, m, i, t1, t2, ans, sum, t, c[512];
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &c[i]);
for (i = 0; i < m; i++) {
scanf("%d", &t);
while (t1 && a[t1 - 1] != t) {
b[t2++] = a[--t1];
ans += c[a[t1]];
}
if (t1) t1--;
while (t2) a[t1++] = b[--t2];
a[t1++] = t;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1005], b[1005];
long long arr[1005];
int cnt;
bool judge(long long x) {
for (int i = 0; i < cnt; i++)
if (arr[i] == x) return false;
return true;
}
void op(int x) {
long long temp = arr[x];
for (int i = x; i > 0; i--) {
arr[i] = arr[i - 1];
}
arr[0] = temp;
}
int main() {
long long n, m;
while (cin >> n >> m) {
cnt = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
for (int i = 0; i < m; i++) {
if (judge(b[i])) {
arr[cnt++] = b[i];
}
if (cnt == n) break;
}
long long ans = 0;
for (int i = 0; i < m; i++) {
long long temp = 0;
for (int j = 0; j < cnt; j++) {
if (arr[j] == b[i]) {
ans += temp;
op(j);
break;
} else {
temp += a[arr[j]];
}
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, m, s, a[10009], b[10009], d[10009];
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= m; i++) cin >> b[i];
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++) d[j] = 0;
for (j = i - 1; j > 0; j--) {
if (b[j] == b[i]) break;
if (d[b[j]] == 0) {
s += a[b[j]];
d[b[j]] = 1;
}
}
}
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ans, r;
int a[600], f[600], t[2000], q[10000], s = 0;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
cin >> t[i];
}
for (int i = 0; i < m; i++) {
if (f[t[i]] == 0) {
ans.push_back(t[i]);
f[t[i]] = 1;
}
}
for (int i = 0; i < ans.size(); i++) q[i] = ans[i];
for (int i = 0; i < m; i++) {
int j = 0;
while (q[j] != t[i]) {
s += a[q[j] - 1];
j++;
}
r.clear();
for (int x = 0; x < n; x++)
if (x != j) r.push_back(q[x]);
q[0] = q[j];
for (int i = 1; i <= r.size(); i++) q[i] = r[i - 1];
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int w[505], sec[1005], l[505];
int main() {
int ret = 0;
bool v[505] = {0};
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= m; i++) {
memset(v, 0, sizeof(v));
scanf("%d", &sec[i]);
for (int j = l[sec[i]] + 1; j < i; j++)
if (!v[sec[j]]) {
v[sec[j]] = 1;
ret += w[sec[j]];
}
l[sec[i]] = i;
}
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long POS(long long x) {
if (x > 0)
return x;
else
return 0;
}
struct shvm {
long double z, y, x;
shvm() {}
shvm(long double z, long double y, long double x) : z(z), y(y), x(x) {}
shvm operator+(const shvm &p) const {
return shvm(z + p.z, y + p.y, x + p.x);
}
shvm operator-(const shvm &p) const {
return shvm(z - p.z, y - p.y, x - p.x);
}
shvm operator*(long double con) const {
return shvm(z * con, y * con, x * con);
}
shvm operator/(long double con) const {
return shvm(z / con, y / con, x / con);
}
bool operator<(const shvm &rhs) const {
return make_pair(z, make_pair(y, x)) <
make_pair(rhs.z, make_pair(rhs.y, rhs.x));
}
bool operator==(const shvm &rhs) const {
return make_pair(z, make_pair(y, x)) ==
make_pair(rhs.z, make_pair(rhs.y, rhs.x));
}
};
int n, m, arr[1005], b[1005], w;
bool vis[1005], fl;
int main() {
cin >> n >> m;
memset(vis, false, sizeof vis);
vector<int> v, v1;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
if (!vis[b[i]]) v.push_back(b[i]), vis[b[i]] = true;
}
long long res = 0;
for (int i = 0; i < m; i++) {
w = b[i];
v1.clear();
v1.push_back(w);
fl = false;
for (int j = 0; j < v.size(); j++) {
if (v[j] == w)
fl = true;
else if (v[j] != w)
v1.push_back(v[j]);
if (!fl) res += arr[v[j] - 1];
}
v = v1;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int id, sum, n, m, w[501], a[502], k, temp, p[502], tot, x, y, d[1001], xx[501];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= m; i++) {
cin >> d[i];
if (p[d[i]] == 0) a[k++] = d[i], p[d[i]] = 1;
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < k; j++) {
if (a[j] == d[i]) {
id = j;
break;
} else
sum += w[a[j]];
}
for (int j = 0; j < id; j++) xx[j] = a[j];
a[0] = a[id];
for (int jj = 1; jj <= id; jj++) {
a[jj] = xx[jj - 1];
}
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = -1e18;
const long long INF = 1e18;
long long n, m, a[510], b[1010], c[510], us[510], ans, k;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
k = 1;
for (int i = 1; i <= m; i++) {
cin >> b[i];
if (us[b[i]] == 0) {
us[b[i]] = 1;
c[k++] = b[i];
}
}
for (int i = 1; i <= n; i++) {
if (us[i] == 0) {
c[k++] = i;
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (b[i] == c[j]) {
for (int k = j; k > 1; k--) {
c[k] = c[k - 1];
}
c[1] = b[i];
break;
}
ans += a[c[j]];
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1234567;
int a[mx], b[mx];
bool ok[mx];
int main() {
long long n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
long long ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 1; j <= n; j++) {
ok[j] = false;
}
for (int j = i - 1; j >= 0; j--) {
if (b[j] == b[i]) {
break;
}
if (ok[b[j]]) {
continue;
}
ok[b[j]] = true;
ans += a[b[j]];
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int b[n], c[m];
int used[n];
memset(used, 0, sizeof(used));
vector<int> ans;
for (auto &it : b) cin >> it;
for (auto &it : c) {
cin >> it;
it--;
if (used[it]) continue;
used[it] = 1;
ans.push_back(it);
}
int64_t sum = 0;
for (auto it : c) {
for (int i = 0; i < ans.size(); i++) {
if (ans[i] == it) {
for (int j = i; j; j--) ans[j] = ans[j - 1];
ans[0] = it;
break;
}
sum += b[ans[i]];
}
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long kl = 0, N, M, a[10000], b[10000], st[10000], in[10000], vt = 1,
k[10000], res = 0;
int main() {
cin >> M >> N;
for (int i = 1; i <= M; i++) cin >> a[i];
for (int i = 1; i <= N; i++) {
cin >> b[i];
if (in[b[i]] == 0) {
in[b[i]] = vt + 1;
st[vt++] = b[i];
k[vt - 1] = kl;
kl += a[b[i]];
}
}
for (int i = 1; i <= N; i++) {
int j;
for (j = 1; j <= M; j++)
if (st[j] == b[i]) break;
res += k[j];
for (int tg = j; tg > 1; tg--) {
st[tg] = st[tg - 1];
k[tg] = k[tg - 1] + a[b[i]];
}
k[1] = 0;
st[1] = b[i];
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
const int mod = 1000000007;
const double pi = (double)22 / 7;
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> wight(n);
for (int i = 0; i < n; cin >> wight[i++])
;
vector<int> book(m);
for (int i = 0; i < m; cin >> book[i++])
;
map<int, bool> u;
vector<int> list;
for (int i = 0; i < m; i++) {
if (!u[book[i]]) {
u[book[i]] = 1;
list.push_back(book[i]);
}
}
int ans = 0;
for (int i = 0; i < m; i++) {
int j = 0;
while (1) {
if (list[j] != book[i])
ans += wight[list[j] - 1];
else if (list[j] == book[i]) {
list.erase(list.begin() + j);
list.insert(list.begin(), book[i]);
break;
}
j++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[510], t[1010];
bool mark[510];
int main() {
int n, m;
long long sum = 0;
vector<int> a;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 0; i < m; i++) cin >> t[i];
for (int i = 0; i < m; i++) {
if (!mark[t[i]]) {
a.push_back(t[i]);
mark[t[i]] = true;
}
}
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
a.push_back(i);
}
}
for (int i = 0; i < m; i++) {
int x = 0;
for (int j = 0; a[j] != t[i]; j++) {
sum += w[a[j]];
x++;
}
for (int j = x; j > 0; j--) {
a[j] = a[j - 1];
}
a[0] = t[i];
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
class S {
public:
int v, i;
};
int n, m;
vector<S> a;
int b[1005];
bool hit[505];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
S temp;
cin >> temp.v;
temp.i = i;
a.push_back(temp);
}
for (int i = 0; i < m; i++) {
cin >> b[i];
b[i]--;
}
vector<S> v;
for (int i = 0; i < m; i++) {
if (!hit[b[i]]) {
hit[b[i]] = true;
v.push_back(a[b[i]]);
}
}
int result = 0;
for (int i = 0; i < m; i++) {
int j;
for (j = 0; v[j].i != b[i]; j++) {
result += v[j].v;
}
S temp = v[j];
v.erase(v.begin() + j);
v.insert(v.begin(), temp);
}
cout << result << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
map<int, bool> mp;
map<int, int> weight;
for (int i = 0; i < (int)(n); i++) {
int x;
cin >> x;
weight[i + 1] = x;
}
deque<int> dq;
int sum = 0;
for (int i = 0; i < (int)(m); i++) {
int x;
cin >> x;
bool found = false;
for (int j = 0; j < (int)(((int)((dq).size()))); j++) {
if (dq[j] == x) {
found = true;
break;
}
}
if (found) {
for (int j = 0; j < (int)(((int)((dq).size()))); j++) {
if (dq[j] == x) {
dq[j] = -1;
break;
}
if (dq[j] != -1) sum += weight[dq[j]];
}
dq.push_front(x);
} else {
for (int j = 0; j < (int)(((int)((dq).size()))); j++)
if (dq[j] != -1) sum += weight[dq[j]];
dq.push_front(x);
}
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
int w[505], b[1005];
int v[505];
int main() {
int n, m, sum = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
for (int i = 2; i <= m; i++) {
memset(v, 0, sizeof(v));
for (int j = i - 1; j > 0; j--) {
if (b[j] == b[i]) break;
if (!v[b[j]]) {
sum += w[b[j]];
v[b[j]] = 1;
}
}
}
printf("%d\n", sum);
}
|
#include <bits/stdc++.h>
using namespace std;
void debug() {
fflush(stdin);
printf("Press any key to continue");
getc(stdin);
fflush(stdin);
}
int n, m;
int w[505];
int l[1005];
int b[1005];
int c[1005];
int last[505];
int sum[1005][505];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
l[i] = last[b[i]];
last[b[i]] = i;
for (int j = 1; j <= n; j++) {
sum[i][j] = sum[i - 1][j] + (b[i] == j ? 1 : 0);
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (j != b[i]) {
int tmp = sum[i][j] - sum[l[i]][j];
if (tmp != 0) c[j]++;
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += w[i] * c[i];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
int w[505];
int b[1005];
for (int i = 0; i < n; i++) scanf("%d", &w[i]);
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
b[i]--;
}
int ans = 0;
int sz = 0;
int ord[505];
int vis[505];
memset(vis, 0, sizeof vis);
for (int i = 0; i < m; i++) {
if (vis[b[i]]) {
int sum = 0;
for (int j = 0; j < sz; j++) {
if (ord[j] == b[i]) {
for (int k = j; k >= 1; k--) ord[k] = ord[k - 1];
ord[0] = b[i];
break;
} else {
sum += w[ord[j]];
}
assert(j != (sz - 1));
}
ans += sum;
} else {
vis[b[i]] = true;
ord[sz++] = b[i];
i--;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll oo = 0x3f3f3f3f3f3f3f3f;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> w(n);
for (auto &a : w) cin >> a;
vector<ll> b(m);
for (auto &a : b) cin >> a, a--;
ll res = 0;
for (ll i = 0; i < m; i++) {
vector<bool> visited(n);
for (ll j = i - 1; j >= 0; j--) {
if (b[i] == b[j]) break;
visited[b[j]] = true;
}
for (ll j = 0; j < n; j++) res += visited[j] ? w[j] : 0;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> w, b;
vector<int> st, loc;
bool vis[1010];
int main() {
int n, m;
cin >> n >> m;
w = vector<int>(n);
b = vector<int>(m);
loc = vector<int>(n);
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < m; i++) {
cin >> b[i];
if (!vis[b[i]]) {
vis[b[i]] = 1;
st.push_back(b[i] - 1);
loc[b[i] - 1] = st.size() - 1;
}
}
int sol = 0;
for (int i = 0; i < m; i++) {
for (int j = loc[b[i] - 1] - 1; j >= 0; j--) {
sol += w[st[j]];
st[j + 1] = st[j];
loc[st[j]]++;
}
st[0] = b[i] - 1;
loc[b[i] - 1] = 0;
}
cout << sol << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, W[2000], B[2000];
int Stack[2000], STop = 0;
bool Used[2000] = {false};
int main() {
cin >> N >> M;
for (int i = 1; i <= N; i++) cin >> W[i];
for (int i = 1; i <= M; i++) cin >> B[i];
for (int i = 1; i <= M; i++)
if (!Used[B[i]]) {
Stack[++STop] = B[i];
Used[B[i]] = true;
}
int Ans = 0;
for (int i = 1; i <= M; i++) {
int p = 1;
while (Stack[p] != B[i]) p++;
for (int j = p - 1; j >= 1; j--) {
Ans += W[Stack[j]];
Stack[j + 1] = Stack[j];
}
Stack[1] = B[i];
}
cout << Ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int q[20000000];
int front = 10000000, tail = front + 1;
int w[505];
int work(int b) {
int sum = 0;
int f = front, t = tail;
while (f < t) {
if (q[f] == -1) {
q[f] = b;
return sum;
}
if (q[f] == b) {
q[f] = 0, front--, q[front] = b;
return sum;
}
sum += w[q[f]];
f++;
}
front--, q[front] = b;
return sum;
}
int main() {
int n, m;
cin >> n >> m;
int sum = 0;
memset(q, -1, sizeof(q));
int i;
for (i = 1; i <= n; i++) scanf("%d", &w[i]);
for (i = 0; i < m; i++) {
int need;
scanf("%d", &need);
sum += work(need);
}
printf("%d\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
int m;
cin >> n >> m;
vector<int> w(n);
for (int _n(n), i(0); i < _n; i++) cin >> w[i];
vector<int> b(m);
for (int _n(m), i(0); i < _n; i++) {
cin >> b[i];
b[i]--;
}
long long ans = 0;
vector<int> top(n);
int ntop = 0;
for (int x : b) {
int pos = 0;
while (pos < ntop && top[pos] != x) {
ans += w[top[pos]];
++pos;
}
if (pos == ntop) ++ntop;
for (int i = pos; i > 0; --i) {
top[i] = top[i - 1];
}
top[0] = x;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10;
int n, t;
int w[N];
int d[N];
int use[510];
int main() {
scanf("%d%d", &n, &t);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int j = 1; j <= t; j++) scanf("%d", &d[j]);
int ans = 0;
for (int i = 1; i <= t; i++) {
memset(use, 0, sizeof(use));
for (int j = i - 1; j; --j) {
if (d[j] == d[i]) break;
use[d[j]] = true;
}
for (int i = 1; i <= n; i++)
if (use[i]) ans += w[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, w[502], ms[1002], last[502];
long long res;
inline long long getsum(int beg, int end) {
set<int> seen;
for (int i = beg + 1; i < end; ++i) seen.insert(ms[i]);
long long acc = 0;
for (set<int>::iterator it = seen.begin(); it != seen.end(); ++it)
acc += w[*it];
return acc;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
while (cin >> n >> m) {
res = 0;
memset(last, 0, sizeof last);
for (int i = 1; i <= n; ++i) cin >> w[i];
ms[0] = 0;
for (int i = 1; i <= m; ++i) {
cin >> ms[i];
res += getsum(last[ms[i]], i);
last[ms[i]] = i;
}
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long w[504], v[1003], b[506];
int main() {
long n, m;
cin >> n >> m;
for (long i = 1; i <= n; i++) cin >> w[i];
for (long i = 1; i <= m; i++) cin >> v[i];
long long int ans = 0;
for (long i = 1; i <= n; i++) {
long str = 0;
for (long j = 1; j <= n; j++) {
b[j] = 0;
}
long long int s = 0;
for (long j = 1; j <= m; j++) {
long h = v[j];
if (h != i) {
if (b[h] <= str) {
b[h] = j;
s = s + w[h];
}
} else {
ans = ans + s;
s = 0;
str = j;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int w[n + 2], d[m + 2], pile[n + 2];
bool visited[n + 2];
memset(visited, 0, sizeof(visited));
int counter = 1, ans = 0;
pile[0] = 0;
w[0] = 0;
for (int i = 1; i < n + 1; i++) {
cin >> w[i];
}
for (int i = 1; i < m + 1; i++) {
cin >> d[i];
if (!visited[d[i]]) pile[counter++] = d[i];
visited[d[i]] = true;
}
for (int i = 1; i < n + 1; i++) {
if (!visited[i]) pile[counter++] = i;
}
for (int i = 1; i < m + 1; i++) {
int j = 1;
while (j <= n) {
if (pile[j] == d[i]) {
break;
}
j++;
}
for (int k = 0; k < j; k++) {
ans += w[pile[k]];
}
int temp = pile[j];
for (int k = j; k > 1; k--) {
pile[k] = pile[k - 1];
}
pile[1] = temp;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1000 + 10;
int w[max_n], b[max_n];
bool vis[max_n];
vector<int> v;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < m; i++) {
cin >> b[i];
b[i]--;
}
memset(vis, 0, sizeof vis);
for (int i = 0; i < m; i++)
if (!vis[b[i]]) {
vis[b[i]] = true;
v.push_back(b[i]);
}
int ans = 0;
for (int i = 0; i < m; i++) {
int ind;
for (int j = 0; j < v.size(); j++)
if (v[j] == b[i]) {
ind = j;
break;
}
for (int j = ind - 1; j >= 0; j--) {
ans += w[v[j]];
swap(v[j], v[j + 1]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[501];
int b[1001];
bool u[501];
int stck[501];
int main() {
ios::sync_with_stdio(true);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> w[i];
;
for (int i = 0; i < m; i++) cin >> b[i];
;
int sti = 0;
for (int i = 0; i < m; i++) {
if (!u[b[i]]) {
stck[sti++] = b[i];
u[b[i]] = true;
}
}
int weight = 0;
for (int i = 0; i < m; i++) {
bool swapf = false;
for (int j = sti - 1; j >= 0; j--) {
if (swapf) {
weight += w[stck[j] - 1];
swap(stck[j], stck[j + 1]);
} else if (stck[j] == b[i])
swapf = true;
}
}
cout << weight;
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int book[600];
int w[600];
bool vis[600];
int plc[600];
int ord[1100];
int n, m;
int main() {
cin.sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> w[i];
}
for (int i = 1; i <= m; i++) {
cin >> ord[i];
}
int pp = 1;
for (int i = 1; i <= m; i++) {
if (!vis[ord[i]]) {
plc[ord[i]] = pp++;
vis[ord[i]] = true;
}
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) plc[i] = pp++;
}
int sol = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (plc[j] < plc[ord[i]]) {
sol += w[j];
plc[j]++;
}
}
plc[ord[i]] = 1;
}
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[505], b[1002];
bool f[505] = {0};
stack<int> s1;
stack<int> s2;
int main() {
int n, m, i, tmp, sum = 0;
cin >> n >> m;
for (i = 1; i <= n; i++) scanf("%d", &w[i]);
for (i = 0; i < m; i++) {
scanf("%d", &b[i]);
if (f[b[i]] == 0) {
f[b[i]] = 1;
s2.push(b[i]);
}
}
while (!s2.empty()) {
s1.push(s2.top());
s2.pop();
}
for (i = 0; i < m; i++) {
while (s1.top() != b[i]) {
sum = sum + w[s1.top()];
s2.push(s1.top());
s1.pop();
}
s1.pop();
while (!s2.empty()) {
s1.push(s2.top());
s2.pop();
}
s1.push(b[i]);
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 3;
int n, m, ans, cnt, a[N], w[N], s[N], v[N];
struct LIST {
int up, down;
} b[N];
inline int gi() {
register int x = 0, p = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + (ch ^ 48), ch = getchar();
return x * p;
}
int main() {
register int i, j, x;
n = gi(), m = gi();
for (i = 1; i <= n; ++i) w[i] = gi();
for (i = 1; i <= m; ++i) {
s[i] = gi();
if (!v[s[i]]) v[s[i]] = 1, a[++cnt] = s[i];
}
for (i = 1; i <= cnt; ++i) {
if (i != 1) b[a[i]].up = a[i - 1];
if (i != cnt) b[a[i]].down = a[i + 1];
}
for (i = 1; i <= m; ++i) {
x = s[i];
while (b[x].up) x = b[x].up, ans += w[x];
if (b[s[i]].up) {
b[b[s[i]].up].down = b[s[i]].down;
if (b[s[i]].down) b[b[s[i]].down].up = b[s[i]].up;
b[s[i]].up = 0, b[s[i]].down = x, b[x].up = s[i];
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500 + 10;
const int M = 1000 + 10;
int w[N], pre[N], vis[N];
int b[M];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &w[i]);
}
int ans = 0;
for (int i = 1; i <= m; ++i) {
scanf("%d", &b[i]);
memset(vis, 0, sizeof vis);
for (int j = pre[b[i]] + 1; j < i; ++j) {
if (!vis[b[j]]) {
vis[b[j]] = 1;
ans += w[b[j]];
}
}
pre[b[i]] = i;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[1100], b[1100], vis[1100];
int main() {
int n, i, j, k, l, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 1; i <= n; i++) scanf("%d", &w[i]);
for (i = 1; i <= m; i++) scanf("%d", &b[i]);
int ans = 0;
for (i = 2; i <= m; i++) {
memset(vis, false, sizeof(vis));
for (j = i - 1; j >= 1; j--) {
if (b[i] == b[j]) break;
if (!vis[b[j]]) {
ans += w[b[j]];
vis[b[j]] = true;
}
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> V, P, R;
vector<bool> vis;
int main() {
int N, M;
cin >> N >> M;
P.resize(N);
V.resize(M);
for (int i = 0; i < N; ++i) cin >> P[i];
for (int i = 0; i < M; ++i) {
cin >> V[i];
V[i]--;
}
vis.assign(N, 0);
for (int i = 0; i < M; ++i) {
if (!vis[V[i]]) {
R.push_back(V[i]);
vis[V[i]] = true;
}
}
long long ans = 0;
for (int i = 0; i < M; ++i) {
int pos = -1, act = V[i];
for (int j = 0; j < N && pos == -1; ++j) {
if (R[j] == act) pos = j;
}
for (int j = pos; j > 0; --j) {
ans += P[R[j - 1]];
R[j] = R[j - 1];
}
R[0] = act;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int weight[510], kanshu[1010], vis[510], st[510];
int main() {
int booknum, day, p, ans, k, n, i, j;
scanf("%d%d", &booknum, &day);
for (i = 1; i <= booknum; i++) scanf("%d", &weight[i]);
memset(vis, 0, sizeof(vis));
p = 1;
ans = 0;
for (i = 1; i <= day; i++) {
scanf("%d", &kanshu[i]);
if (vis[kanshu[i]] == 0) {
st[p++] = kanshu[i];
vis[kanshu[i]] = 1;
}
}
for (i = 2; i <= day; i++) {
for (j = 1; j <= p; j++) {
if (kanshu[i] == st[j])
break;
else
ans += weight[st[j]];
}
n = j;
for (j = n - 1; j >= 1; j--) st[j + 1] = st[j];
st[1] = kanshu[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int weights[10000];
int order[10000];
int set[10000];
struct llist {
int data;
int index;
struct llist *next;
};
void push(struct llist **head, int data, int index) {
struct llist *newnode = (struct llist *)malloc(sizeof(struct llist));
newnode->data = data;
newnode->index = index;
newnode->next = *head;
*head = newnode;
}
void pop(struct llist **head) {
struct llist *tempnode = *head;
*head = (*head)->next;
free(tempnode);
}
void rmv(struct llist *curr) {
struct llist *next = curr->next->next;
free(curr->next);
curr->next = next;
}
int w_search(struct llist **head, int match) {
int i = 0;
int total_data = 0;
push(head, 0, match);
struct llist *prevnode = *head;
struct llist *tempnode = prevnode->next;
while (tempnode != NULL && tempnode->index != match) {
total_data += tempnode->data;
prevnode = tempnode;
tempnode = prevnode->next;
}
(*head)->data = tempnode->data;
rmv(prevnode);
return total_data;
}
void reverse(struct llist **head) {
struct llist *nextnode = *head;
struct llist *currnode = *head;
struct llist *prevnode = NULL;
while (nextnode != NULL) {
nextnode = currnode->next;
currnode->next = prevnode;
prevnode = currnode;
currnode = nextnode;
}
*head = prevnode;
}
int main() {
struct llist *head = NULL;
int n, m;
scanf("%d%d", &n, &m);
int i, j;
for (i = 1; i <= n; i++) scanf("%d", &weights[i]);
for (i = 1; i <= m; i++) scanf("%d", &order[i]);
int totalset = 0;
for (i = 1; i <= m && totalset != n; i++) {
if (set[order[i]] == 0) {
push(&head, weights[order[i]], order[i]);
set[order[i]] = 1;
;
totalset++;
}
}
reverse(&head);
int totalweight = 0;
for (i = 1; i <= m; i++) {
totalweight += w_search(&head, order[i]);
}
printf("%d\n", totalweight);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > books;
vector<int> w, q, st;
int main() {
int n;
cin >> n;
int m;
cin >> m;
w.resize(n);
books.resize(n);
for (int i = 0; i < n; ++i) {
cin >> w[i];
books[i].first = 1111;
books[i].second = i;
}
q.resize(m);
for (int i = 0; i < m; ++i) {
cin >> q[i];
--q[i];
books[q[i]].first = min(i, books[q[i]].first);
}
sort(books.begin(), books.end());
reverse(books.begin(), books.end());
int ans = 0;
for (int i = 0; i < m; ++i) {
int j = books.size() - 1;
while ((books[j].second != q[i]) && (j > 0)) {
ans += w[books[j].second];
--j;
}
books.erase(books.begin() + j);
books.push_back(make_pair(0, q[i]));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static long long m1[10000], m2[10000], m3[10000], m5[10000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, res = 0;
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> m1[i];
for (long long i = 1; i <= m; ++i) {
cin >> m3[i];
memset(m5, 0, sizeof(m5));
for (long long j = i - 1; j > m2[m3[i]]; --j) {
res += m1[m3[j]] * (1 - m5[m3[j]]);
m5[m3[j]] = 1;
}
m2[m3[i]] = i;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
cin >> n >> m;
int w[n];
for (i = 0; i < n; i++) {
cin >> w[i];
}
int r[m], ans = 0;
for (i = 0; i < m; i++) cin >> r[i];
for (i = 1; i < m; i++) {
int hs[512] = {0};
for (j = i - 1; j >= 0; j--) {
if (r[j] == r[i]) break;
if (hs[r[j]] == 0) {
ans += w[r[j] - 1];
hs[r[j]] = 1;
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (-1u) / 2;
const long long int INF2 = (-1ull) / 2;
int a, b, i, d[1011000], j, k, n, m, timer = 0, l, r, x, y, us[500020];
int c[1011000], cnt = 0, fl = 0, a2, a3 = -1000000, ans = 0;
vector<pair<int, pair<int, int> > > v;
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (i = 0; i < n; i++) {
scanf("%d", &c[i]);
us[i + 1] = INF;
}
for (i = 0; i < m; i++) {
scanf("%d", &d[i]);
if (us[d[i]] == INF) us[d[i]] = i + 1;
}
for (i = 0; i < n; i++) {
v.push_back(make_pair(us[i + 1], make_pair(i + 1, c[i])));
}
sort(v.begin(), v.end());
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (v[j].second.first == d[i]) break;
cnt += v[j].second.second;
}
for (; j > 0; j--) {
swap(v[j], v[j - 1]);
}
}
cout << cnt << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.