forked from watashi/AlgoSolution
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Japan Alumni Group Summer Camp 2012 Day 3A
- Loading branch information
Showing
5 changed files
with
455 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,86 @@ | ||
#include <map> | ||
#include <stack> | ||
#include <bitset> | ||
#include <cstdio> | ||
#include <cstdlib> | ||
#include <cstring> | ||
#include <utility> | ||
#include <algorithm> | ||
|
||
using namespace std; | ||
|
||
typedef bitset<256> Bitset; | ||
|
||
int eval(int lhs, int rhs, char op) { | ||
switch (op) { | ||
case '+': return (lhs + rhs) & 255; | ||
case '-': return (lhs - rhs + 256) & 255; | ||
case '*': return (lhs * rhs) & 255; | ||
case '/': return (lhs / rhs) & 255; | ||
default: return -1; | ||
} | ||
} | ||
|
||
Bitset range(int l, int r) { | ||
Bitset ret; | ||
for (int i = l; i < r; ++i) { | ||
ret.set(i); | ||
} | ||
return ret; | ||
} | ||
|
||
int main() { | ||
map<string, pair<int, int> > var; | ||
stack<Bitset> val; | ||
char buf[80], *p; | ||
int n, x, y; | ||
|
||
scanf("%d", &n); | ||
for (int i = 0; i < n; ++i) { | ||
scanf("%s%d%d", buf, &x, &y); | ||
var[buf] = make_pair(x, y + 1); | ||
} | ||
|
||
scanf("%d", &n); | ||
for (int i = 0; i < n; ++i) { | ||
scanf("%s", buf); | ||
x = strtol(buf, &p, 10); | ||
if (*p == '\0') { | ||
val.push(range(x, x + 1)); | ||
} else if (strchr("+-*/", buf[0]) == NULL) { | ||
pair<int, int> snd = var[buf]; | ||
val.push(range(snd.first, snd.second)); | ||
} else { | ||
Bitset rhs = val.top(); | ||
val.pop(); | ||
Bitset lhs = val.top(); | ||
val.pop(); | ||
if (buf[0] == '/' && rhs[0]) { | ||
puts("error"); | ||
return 0; | ||
} else { | ||
Bitset ret; | ||
for (int i = 0; i < (int)lhs.size(); ++i) { | ||
if (!lhs[i]) { | ||
continue; | ||
} | ||
for (int j = 0; j < (int)rhs.size(); ++j) { | ||
if (!rhs[j]) { | ||
continue; | ||
} | ||
ret.set(eval(i, j, buf[0])); | ||
} | ||
} | ||
val.push(ret); | ||
} | ||
} | ||
} | ||
puts("correct"); | ||
return 0; | ||
} | ||
|
||
//Run# Author Problem Status Lang Time Memory Submission Date | ||
//#486411 watashi B : Accepted C++ 00:00 sec 1072 KB Sun Sep 16 13:17:42 | ||
|
||
//Run# Author Problem Status Lang Time Memory Code Submission Date | ||
//#490463 watashi 2435 : Accepted C++ 00:00 sec 1072 KB 2101 Bytes Thu Sep 20 22:19:07 |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,97 @@ | ||
#include <cstdio> | ||
#include <vector> | ||
#include <numeric> | ||
#include <algorithm> | ||
|
||
using namespace std; | ||
|
||
const int MAXL = 5; | ||
const int MAXN = 218; | ||
const long long MOD = 1000000007LL; | ||
|
||
long long f[MAXN], c[MAXN][MAXN], x[MAXN]; | ||
long long ten[MAXL * MAXN]; | ||
|
||
void init() { | ||
f[0] = 1; | ||
for (int i = 1; i < MAXN; ++i) { | ||
f[i] = f[i - 1] * i % MOD; | ||
} | ||
|
||
for (int i = 0; i < MAXN; ++i) { | ||
c[i][0] = 1; | ||
for (int j = 1; j <= i; ++j) { | ||
c[i][j] = c[i - 1][j - 1] + c[i - 1][j]; | ||
if (c[i][j] >= MOD) { | ||
c[i][j] -= MOD; | ||
} | ||
} | ||
} | ||
|
||
for (int i = 0; i < MAXN; ++i) { | ||
x[i] = 0; | ||
for (int j = 0; j <= i; ++j) { | ||
x[i] = (x[i] + c[i][j] * f[j]) % MOD; | ||
} | ||
} | ||
|
||
ten[0] = 1; | ||
for (int i = 1; i < MAXL * MAXN; ++i) { | ||
ten[i] = ten[i - 1] * 10 % MOD; | ||
} | ||
} | ||
|
||
int a[MAXN]; | ||
|
||
int main() { | ||
int n, t, s[MAXL]; | ||
vector<int> v[MAXL]; | ||
|
||
init(); | ||
scanf("%d", &n); | ||
for (int i = 0; i < n; ++i) { | ||
scanf("%d", &t); | ||
v[upper_bound(ten, ten + MAXN, t) - ten].push_back(t); | ||
} | ||
for (int i = 0; i < MAXL; ++i) { | ||
s[i] = accumulate(v[i].begin(), v[i].end(), 0LL); | ||
} | ||
|
||
int i[MAXL]; | ||
long long ans = 0; | ||
|
||
#define FOR_I(k) for (i[k] = 0; i[k] <= (int)v[k].size(); ++i[k]) | ||
FOR_I(0) FOR_I(1) FOR_I(2) FOR_I(3) FOR_I(4) { | ||
int z = 0, nz = 0, sz = 0, len = 0; | ||
for (int k = 0; k < MAXL; ++k) { | ||
sz += i[k]; | ||
nz += (int)v[k].size() - i[k]; | ||
len += max(k, 1) * i[k]; | ||
} | ||
z = (int)v[0].size() - i[0]; | ||
nz -= z + 1; | ||
if (nz < 0) { | ||
continue; | ||
} | ||
for (int k = 1; k < MAXL; ++k) { | ||
if (i[k] < (int)v[k].size()) { | ||
long long cnt = f[sz]; | ||
for (int kk = 0; kk < MAXL; ++kk) { | ||
cnt = cnt * c[v[kk].size() - (kk == k ? 1 : 0)][i[kk]] % MOD; | ||
} | ||
if (nz > 0) { | ||
cnt = cnt * (nz * x[nz - 1 + z] % MOD + 1) % MOD; | ||
} | ||
ans = (ans + s[k] * ten[len] % MOD * cnt) % MOD; | ||
} | ||
} | ||
} | ||
#undef FOR_I | ||
printf("%lld\n", ans % MOD); | ||
|
||
return 0; | ||
} | ||
|
||
//Run# Author Problem Status Lang Time Memory Code Submission Date | ||
//#490567 watashi 2436 : Accepted C++ 00:75 sec 1440 KB 2234 Bytes Fri Sep 21 00:00:54 | ||
|
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,105 @@ | ||
#include <set> | ||
#include <map> | ||
#include <cctype> | ||
#include <cstdio> | ||
#include <vector> | ||
#include <string> | ||
#include <numeric> | ||
#include <sstream> | ||
#include <algorithm> | ||
|
||
using namespace std; | ||
|
||
const int MAXN = 52; | ||
const int MOD = 1000000007; | ||
|
||
set<string> done; | ||
map<string, vector<string> > mp; | ||
|
||
vector<string> gao(const string& key) { | ||
vector<string>& val = mp[key]; | ||
|
||
if (done.insert(key).second) { | ||
vector<string> swp; | ||
for (vector<string>::const_iterator it = val.begin(); it != val.end(); ++it) { | ||
if (it->at(0) == '[') { | ||
swp.push_back(it->substr(1, it->length() - 2)); | ||
} else if (isupper(it->at(0))) { | ||
swp.push_back(*it); | ||
} else { | ||
vector<string> tmp = gao(*it); | ||
swp.insert(swp.end(), tmp.begin(), tmp.end()); | ||
} | ||
} | ||
val.swap(swp); | ||
if ((int)val.size() >= 4 * MAXN) { | ||
val.resize(4 * MAXN); | ||
} | ||
} | ||
|
||
return val; | ||
} | ||
|
||
int dp[MAXN][MAXN][MAXN][MAXN]; | ||
|
||
int main() { | ||
int n[4], m; | ||
string dna, tok; | ||
char buf[4096]; | ||
|
||
for (int i = 0; i < 4; ++i) { | ||
scanf("%d", &n[i]); | ||
} | ||
scanf("%d", &m); | ||
for (int i = 0; i < m; ++i) { | ||
scanf(" %[a-z]:", buf); | ||
vector<string>& v = mp[buf]; | ||
if (i == 0) { | ||
dna = buf; | ||
} | ||
scanf(" %[^\n]", buf); | ||
istringstream iss(buf); | ||
while (iss >> tok) { | ||
v.push_back(tok); | ||
} | ||
} | ||
|
||
vector<string> vs = gao(dna); | ||
if ((int)vs.size() == accumulate(n, n + 4, 0)) { | ||
dp[0][0][0][0] = 1; | ||
for (int i = 0; i < (int)vs.size(); ++i) { | ||
for (int u = 0; u <= i && u <= n[0]; ++u) { | ||
for (int v = 0; u + v <= i && v <= n[1]; ++v) { | ||
for (int w = 0; u + v + w <= i && w <= n[2]; ++w) { | ||
int r = i - u - v - w; | ||
if (r <= n[3]) { | ||
const int& src = dp[u][v][w][r]; | ||
if (src != 0) { | ||
#define GAO(ch, a, b, c, d) \ | ||
if (vs[i].find(ch) != string::npos) {\ | ||
int& dest = dp[u + a][v + b][w + c][r + d];\ | ||
dest += src;\ | ||
if (dest >= MOD) {\ | ||
dest -= MOD;\ | ||
}\ | ||
} | ||
GAO('A', 1, 0, 0, 0) | ||
GAO('T', 0, 1, 0, 0) | ||
GAO('G', 0, 0, 1, 0) | ||
GAO('C', 0, 0, 0, 1) | ||
#undef GAO | ||
} | ||
} | ||
} | ||
} | ||
} | ||
} | ||
} | ||
printf("%d\n", dp[n[0]][n[1]][n[2]][n[3]]); | ||
|
||
return 0; | ||
} | ||
|
||
//Run# Author Problem Status Lang Time Memory Code Submission Date | ||
//#490596 watashi 2437 : Accepted C++ 00:32 sec 29772 KB 2661 Bytes Fri Sep 21 00:57:59 | ||
|
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,100 @@ | ||
import java.io.*; | ||
import java.util.*; | ||
|
||
abstract class MappingItem { | ||
public int indent = 0; | ||
|
||
public MappingItem get(String key) { | ||
return MappingNull.NULL; | ||
} | ||
|
||
public String toString() { | ||
return "no such property"; | ||
} | ||
} | ||
|
||
class MappingNull extends MappingItem { | ||
static MappingNull NULL = new MappingNull(); | ||
|
||
private MappingNull() { | ||
} | ||
} | ||
|
||
class MappingString extends MappingItem { | ||
String value; | ||
|
||
public MappingString(String value) { | ||
this.value = value; | ||
} | ||
|
||
public String toString() { | ||
return "string \"" + value + "\""; | ||
} | ||
} | ||
|
||
class MappingObject extends MappingItem { | ||
HashMap<String, MappingItem> object = new HashMap<String, MappingItem>(); | ||
|
||
public void put(String key, MappingItem value) { | ||
object.put(key, value); | ||
} | ||
|
||
public MappingItem get(String key) { | ||
if (object.containsKey(key)) { | ||
return object.get(key); | ||
} else { | ||
return MappingNull.NULL; | ||
} | ||
} | ||
|
||
public String toString() { | ||
return "object"; | ||
} | ||
} | ||
|
||
public class Main { | ||
public static void main(String[] args) throws IOException { | ||
BufferedReader in = new BufferedReader( | ||
new InputStreamReader(System.in)); | ||
String selector = in.readLine(); | ||
String[] query = selector.split("\\."); | ||
|
||
MappingObject yaml = new MappingObject(); | ||
yaml.indent = -1; | ||
Stack<MappingObject> s = new Stack<MappingObject>(); | ||
s.push(yaml); | ||
|
||
String str; | ||
while ((str = in.readLine()) != null) { | ||
int indent = 0; | ||
while (indent < str.length() && str.charAt(indent) == ' ') { | ||
++indent; | ||
} | ||
str = str.substring(indent); | ||
while (s.peek().indent >= indent) { | ||
s.pop(); | ||
} | ||
if (str.indexOf(':') != str.length() - 1) { | ||
String[] pair = str.split(": ", 2); | ||
s.peek().put(pair[0], new MappingString(pair[1])); | ||
} else { | ||
MappingObject prop = new MappingObject(); | ||
prop.indent = indent; | ||
s.peek().put(str.substring(0, str.length() - 1), prop); | ||
s.push(prop); | ||
} | ||
} | ||
|
||
MappingItem p = yaml; | ||
for (int i = 1; i < query.length; ++i) { | ||
p = p.get(query[i]); | ||
} | ||
System.out.println(p); | ||
} | ||
} | ||
|
||
//Run# Author Problem Status Lang Time Memory Submission Date | ||
//#486482 watashi E : Accepted JAVA 00:08 sec 11000 KB Sun Sep 16 13:58:51 | ||
|
||
//Run# Author Problem Status Lang Time Memory Code Submission Date | ||
//#490464 watashi 2438 : Accepted JAVA 00:08 sec 11000 KB 2566 Bytes Thu Sep 20 22:19:21 |
Oops, something went wrong.