text stringlengths 49 983k |
|---|
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
bool check(char c)
{
char v = '0';
for(int i = 0; i <= 9; i++){
if(c == (char)(v+i)){
return true;
}
}
return false;
}
string cfunc(string str, int n)
{
string s = str.substr(1);
s += str[0];
return s;
}
string jfunc(string str, int n)
{
string s = str.substr(0, n-1);
s = str[n-1] + s;
return s;
}
string efunc(string str, int n)
{
string s;
if(n%2 == 0){
s = str.substr(n/2);
s += str.substr(0, n/2);
} else {
s = "";
for(int i = n/2+1; i < n; i++){
s += str[i];
}
s += str[n/2];
for(int i = 0; i < n/2; i++){
s += str[i];
}
}
return s;
}
string afunc(string str, int n)
{
string s = str;
reverse(s.begin(), s.end());
return s;
}
string pfunc(string str, int n)
{
string s = str;
for(int i = 0; i < n; i++){
if(check(s[i])){
if(s[i] == '0'){
s[i] = '9';
} else {
s[i] = (char)(s[i]-1);
}
}
}
return s;
}
string mfunc(string str, int n)
{
string s = str;
for(int i = 0; i < n; i++){
if(check(s[i])){
if(s[i] == '9'){
s[i] = '0';
} else {
s[i] = (char)(s[i]+1);
}
}
}
return s;
}
int main()
{
int n, l, m;
string str, st;
cin >> n;
while(n--){
cin >> st;
cin >> str;
l = st.size();
m = str.size();
for(int i = l-1; i >= 0; i--){
if(st[i] == 'J'){
str = jfunc(str, m);
} else if(st[i] == 'C'){
str = cfunc(str, m);
} else if(st[i] == 'E'){
str = efunc(str, m);
} else if(st[i] == 'A'){
str = afunc(str, m);
} else if(st[i] == 'P'){
str = pfunc(str, m);
} else if(st[i] == 'M'){
str = mfunc(str, m);
}
}
cout << str << endl;
}
return 0;
} |
#include<iostream>
#include<string>
#include<algorithm>
#include <utility>
using namespace std;
string dec(string str,char c){
if(c=='J'){
int e=str.size()-1;
str=str[e]+str;
str.pop_back();
}
else if(c=='C'){
str=str+str[0];
str.erase(str.begin());
}
else if(c=='E'){
int t=0;
while(2*t<(str.size()-1)){
swap(str[t],str[(str.size()+1)/2+t]);
t++;
}
}
else if(c=='A'){
reverse(str.begin(),str.end());
}
else if(c=='P'){
for(int i=0;i<str.size();i++){
if(str[i]>='0' && str[i]<='9')str[i]=((str[i]-'0')+9)%10+'0';
}
}
else if(c=='M'){
for(int i=0;i<str.size();i++){
if(str[i]>='0' && str[i]<='9')str[i]=((str[i]-'0')+1)%10+'0';
}
}
return str;
}
int main(){
int n;
cin>>n;
while(n--){
string ord,mes;
cin>>ord>>mes;
reverse(ord.begin(),ord.end());
for(int i=0;i<ord.size();i++){
mes=dec(mes,ord[i]);
}
cout<<mes<<endl;
}
} |
#include <cctype>
#include <iostream>
#include <string>
using namespace std;
void solve() {
string order, message;
cin >> order >> message;
for (int i = order.size() - 1; i >= 0; i--) {
int l;
switch (order[i]) {
case 'J':
message = (*message.rbegin()) + message.substr(0, message.size() - 1);
break;
case 'C':
message = message.substr(1) + message[0];
break;
case 'E':
l = message.size() / 2;
if (message.size() & 1) {
message = message.substr(message.size() - l) + message[l] + message.substr(0, l);
}
else {
message = message.substr(message.size() - l) + message.substr(0, l);
}
break;
case 'A':
message = string(message.rbegin(), message.rend());
break;
case 'P':
for (unsigned j = 0; j < message.size(); j++) {
if (isdigit(message[j])) {
if (message[j] == '0') {
message[j] = '9';
}
else {
message[j]--;
}
}
}
break;
case 'M':
for (unsigned j = 0; j < message.size(); j++) {
if (isdigit(message[j])) {
if (message[j] == '9') {
message[j] = '0';
}
else {
message[j]++;
}
}
}
break;
}
}
cout << message << endl;
}
int main () {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
solve();
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=(0);(i)<(int)(n);++(i))
using ll = long long;
string s, t;
void j() {
char c = t[0];
for (int i=1; i<t.size(); ++i) {
t[i-1] = t[i];
}
t[t.size()-1] = c;
}
void c() {
char c = t[t.size()-1];
for (int i=t.size()-2; i>=0; --i) {
t[i+1] = t[i];
}
t[0] = c;
}
void a() {
reverse(t.begin(), t.end());
}
void e() {
if (t.size()%2) {
char c = t[t.size()/2];
string a = t.substr(0, t.size()/2), b = t.substr(t.size()/2+1, t.size()/2);
t = b + c + a;
}
else {
string a = t.substr(0, t.size()/2), b = t.substr(t.size()/2, t.size()/2);
t = b + a;
}
}
void p() {
rep(i, t.size()) {
if (t[i] == '9') t[i] = '0';
else if ('0' <= t[i] and t[i] <= '9') t[i]++;
}
}
void m() {
rep(i, t.size()) {
if (t[i] == '0') t[i] = '9';
else if ('0' <= t[i] and t[i] <= '9') t[i]--;
}
}
int main() {
int n;
cin >> n;
rep(i, n) {
cin >> s >> t;
reverse(s.begin(), s.end());
rep(i, s.size()) {
switch(s[i]) {
case 'A': a(); break;
case 'J': c(); break;
case 'C': j(); break;
case 'P': m(); break;
case 'M': p(); break;
case 'E': e(); break;
}
}
cout << t << endl;
}
} |
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main(){
int n;
string er, ge;
char tmp;
int mid;
cin >> n;
while (n--){
cin >> er;
cin >> ge;
for (int i = er.size() - 1; i >= 0; i--){
if (er[i] == 'J'){
tmp = ge[ge.size() - 1];
for (int j = ge.size() - 1; j > 0; j--){
ge[j] = ge[j - 1];
}
ge[0] = tmp;
}
else if (er[i] == 'C'){
tmp = ge[0];
for (int j = 0; j < ge.size()-1; j++){
ge[j] = ge[j + 1];
}
ge[ge.size()-1] = tmp;
}
else if (er[i] == 'E'){
mid = ge.size() / 2 + ge.size() % 2;
for (int i = 0; i < ge.size() / 2; i++){
swap(ge[i], ge[i + mid]);
}
}
else if (er[i] == 'A'){
for (int i = 0; i < ge.size() / 2; i++){
swap(ge[i], ge[ge.size()-1-i]);
}
}
else if (er[i] == 'P'){
for (int i = 0; i < ge.size(); i++){
if ('0' <= ge[i] && ge[i] <= '9'){
if (ge[i] == '0') ge[i] = '9';
else ge[i]--;
}
}
}
else if (er[i] == 'M'){
for (int i = 0; i < ge.size(); i++){
if ('0' <= ge[i] && ge[i] <= '9'){
if (ge[i] == '9') ge[i] = '0';
else ge[i]++;
}
}
}
}
cout << ge << endl;
}
return 0;
} |
#include <algorithm>
#include <iostream>
using namespace std;
string rotate_left (string s) {
return s.substr(1, s.size() - 1) + s.substr(0, 1);
}
string rotate_right (string s) {
return s.substr(s.size() - 1, 1) + s.substr(0, s.size() - 1);
}
string swap_half (string s) {
bool even = s.size() % 2 == 0;
int h = s.size() /2;
if (even) {
return s.substr(h, h) + s.substr(0, h);
} else {
return s.substr(h + 1, h) + s.substr(h, 1) + s.substr(0, h);
}
}
string rev(string s) {
reverse(begin(s), end(s));
return s;
}
string inc_dig (string s) {
string ret = "";
for (char c : s) {
if(isdigit(c)) {
ret += ((c - '0') + 1) % 10 + '0';
} else {
ret += c;
}
}
return ret;
}
string dec_dig (string s) {
string ret = "";
for (char c : s) {
if(isdigit(c)) {
ret += ((c - '0') + 9) % 10 + '0';
} else {
ret += c;
}
}
return ret;
}
int main() {
int n;
cin >> n;
while (n--) {
string opers, s;
cin >> opers >> s;
for (auto op = opers.rbegin(); op != opers.rend(); ++op) {
if(*op == 'J') {
s = rotate_right(s);
} else if (*op == 'C') {
s = rotate_left(s);
} else if (*op == 'E') {
s = swap_half(s);
} else if (*op == 'A') {
s = rev(s);
} else if (*op == 'P') {
s = dec_dig(s);
} else if (*op == 'M') {
s = inc_dig(s);
}
}
cout << s << endl;
}
return 0;
} |
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cstdio>
#include <cstring>
using namespace std;
#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define DEB 0
#define all(x) x.begin(), x.end()
int main(){
int n;
string order, mess, tmp;
cin>>n;
while(n--){
cin >> order >> mess;
for(int i=order.size()-1; i>=0; i--){
switch(order[i]){
case 'C':
mess = mess.substr(1) + mess.substr(0,1);
break;
case 'J':
mess = mess.substr(mess.size()-1) + mess.substr(0,mess.size()-1);
break;
case 'E':
if( mess.size()%2==0 ){
mess = mess.substr(mess.size()/2) + mess.substr(0,mess.size()/2);
}else{
mess = mess.substr(mess.size()/2+1) + mess[mess.size()/2] + mess.substr(0,mess.size()/2);
}
break;
case 'A':
reverse(all(mess));
break;
case 'P':
rep(j,mess.size()){
if( '0'<=mess[j] && mess[j]<='9' ){
if( mess[j]=='0' ){
mess[j] = '9';
}else{
mess[j]--;
}
}
}
break;
case 'M':
rep(j,mess.size()){
if( '0'<=mess[j] && mess[j]<='9' ){
if( mess[j]=='9' ){
mess[j] = '0';
}else{
mess[j]++;
}
}
}
break;
}
#if DEB
cout << ":: " << mess << endl;
#endif
}
cout << mess << endl;
}
return 0;
} |
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cctype>
using namespace std;
const char person[] = {'J', 'C', 'E', 'A', 'P', 'M'};
vector<char> decode(const vector<char>& messangers, const vector<char>& message){
vector<char> ans;
for(int i=0;i<message.size();++i){
ans.push_back(message[i]);
}
for(int i=messangers.size()-1;i>=0;--i){
if(messangers[i]==person[0]){
for(int j=ans.size()-1;j>0;--j){
swap(ans[j],ans[j-1]);
}
}else if(messangers[i]==person[1]){
for(int j=0;j<ans.size()-1;++j){
swap(ans[j],ans[j+1]);
}
}else if(messangers[i]==person[2]){
for(int j=0,k;j<ans.size()/2;++j){
ans.size()%2==1 ? k=ans.size()/2+1 : k=ans.size()/2;
swap(ans[j],ans[j+k]);
}
}else if(messangers[i]==person[3]){
reverse(ans.begin(), ans.end());
}else if(messangers[i]==person[4]){
for(int j=0;j<ans.size();++j){
if(isdigit(ans[j])){
if(ans[j]=='0') ans[j]='9';
else --ans[j];
}
}
}else if(messangers[i]==person[5]){
for(int j=0;j<ans.size();++j){
if(isdigit(ans[j])){
if(ans[j]=='9') ans[j]='0';
else ++ans[j];
}
}
}
}
return ans;
}
int main(){
int n;
cin>>n;
for(int index=0;index<n;++index){
vector<char> messangers,message;
string tmp;
cin>>tmp;
for(int i=0;i<tmp.size();++i)
messangers.push_back(tmp.at(i));
cin>>tmp;
for(int i=0;i<tmp.size();++i)
message.push_back(tmp.at(i));
vector<char> ans;
ans = decode(messangers, message);
for(int i=0;i<ans.size();++i)
cout << ans.at(i);
cout << endl;
}
return 0;
} |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cctype>
using namespace std;
string revJ(string s) {
return s[s.size()-1] + s.substr(0, s.size()-1);
}
string revC(string s) {
return s.substr(1) + s[0];
}
string revE(string s) {
int n = s.size();
string ret = s.substr(n-n/2);
if(n % 2) ret += s[n/2];
ret += s.substr(0, n/2);
return ret;
}
string revA(string s) {
reverse(s.begin(), s.end());
return s;
}
string revP(string s) {
for(int i=0; i<s.size(); i++)
if(isdigit(s[i])) s[i] = static_cast<char>(((s[i]-'0') + 9) % 10 + '0');
return s;
}
string revM(string s) {
for(int i=0; i<s.size(); i++)
if(isdigit(s[i])) s[i] = static_cast<char>(((s[i]-'0') + 11) % 10 + '0');
return s;
}
int main() {
int n;
cin >> n;
while(n--) {
string cmd, s;
cin >> cmd >> s;
reverse(cmd.begin(), cmd.end());
int Ncmd = cmd.size();
for(int i=0; i<Ncmd; i++) {
switch(cmd[i]) {
case 'A': s = revA(s); break;
case 'C': s = revC(s); break;
case 'E': s = revE(s); break;
case 'J': s = revJ(s); break;
case 'M': s = revM(s); break;
case 'P': s = revP(s); break;
}
}
cout << s << endl;
}
return 0;
} |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
#define debug 0
int main(){
/*
J 先頭を最後尾に
C 最後尾を先頭に
E 前半と後半を入れ替える(文字列が奇数なら真ん中は残す)
A 文字列をひっくり返す
P プラス
M マイナス
*/
int n;
for(cin>>n;n>0;n--){
string order,str;
cin>>order>>str;
if(debug)cout<<"$"<<str<<endl;
for(int i=order.size()-1;i>=0;i--){
if(order[i]=='J'){
string tmp="";
tmp+=str[str.size()-1];
for(int j=0;j<str.size()-1;j++)tmp+=str[j];
str=tmp;
}
if(order[i]=='C'){
string tmp="";
for(int j=1;j<str.size();j++)tmp+=str[j];
tmp+=str[0];
str=tmp;
}
if(order[i]=='E'){
string tmp="";
if(str.size()%2){//奇数文字列
for(int j=str.size()/2+1;j<str.size();j++)tmp+=str[j];
tmp+=str[str.size()/2];
for(int j=0;j<str.size()/2;j++)tmp+=str[j];
}
else{
for(int j=str.size()/2;j<str.size();j++)tmp+=str[j];
for(int j=0;j<str.size()/2;j++)tmp+=str[j];
}
str=tmp;
}
if(order[i]=='A'){
reverse(str.begin(), str.end());
}
if(order[i]=='P'){
for(int j=0;j<str.size();j++){
if('0'<str[j]&&str[j]<='9')str[j]--;
else if(str[j]=='0')str[j]='9';
}
}
if(order[i]=='M'){
for(int j=0;j<str.size();j++){
if('0'<=str[j]&&str[j]<'9')str[j]++;
else if(str[j]=='9')str[j]='0';
}
}
if(debug)cout<<"#"<<str<<endl;
}
cout<<str<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<string,string> P;
int bnf();
set<P> used;
map<char,int> M;
string S;
int idx,valid;
char ch[8]={'0','1','+','-','*','(',')','='};
int ord[8];
bool check(string a){//??????????????????°???¨???????????????????????¢????
int par=0;
for(char s:a){
par += (s == '(') - (s == ')');
if(s == '=') return 0;
if(par < 0) return 0;
}
return par==0;
}
int getNum(){ //???????????????°????????????
int res = 0;
if(S[idx] == '0' && isdigit(S[idx+1])) valid = 0;
while(isdigit(S[idx]))res = res*2 + S[idx++]-'0';
return res;
}
int cal(){
char ch = S[idx];
int res = 0,sign = 1;
if(ch=='+'||ch=='*'||ch==')'){ valid = 0;return 0;}
while(S[idx] == '-') idx++, sign *= -1;
ch = S[idx];
if(isdigit(ch)){
res = sign*getNum();
if(S[idx] == '*'){idx++; return res * cal();}
return res;
}
else if(ch == '(') {
idx++;res = sign*bnf();idx++;
return res;
}
valid = 0;
return 0;
}
int bnf(){
int res = cal();
while(idx<(int)S.size()){
if(valid == 0) return -1;
char ch = S[idx];
if(ch == '('){valid = 0;}
else if(ch == '*'){idx++;res *= cal();}
else if(ch == '+'){idx++;res += cal();}
else if(ch == '-'){idx++;res -= cal();}
else if(ch != ')') valid = 0;
else break;
}
if(valid ==0) return -1;
return res;
}
string mkS(string a){
string res;
for(char s:a){
if(isalpha(s))res += ch[ ord[ M[s] ] ];
else res += s;
}
return res;
}
int calc(string A,string B){
if(A.size()==0 || B.size()==0) return 0;
if(used.count(P(A,B)))return 0;
used.insert(P(A,B));
valid = check(A) && check(B);
idx = 0;
S = A;
int ra = bnf();
idx = 0;
S = B;
int rb = bnf();
//if(valid)cout<<A<<"="<<B<<" "<<valid<<" "<<ra<<" "<<rb<<endl;
return ra == rb && valid;
}
int calc(string s){
s = mkS(s);
for(int i=0;i<(int)s.size();i++)
if(s[i]=='=') return calc(s.substr(0,i),s.substr(i+1,s.size()-i-1));
return 0;
}
int dfs(int num,string &s){
if(num == 8) return calc(s);
int res = 0;
for(int i=0;i<8;i++){
if(ord[i] != -1)continue;
ord[i] = num;
res +=dfs(num+1,s);
ord[i] = -1;
}
return res;
}
int main(){
string str;
cin>>str;
if(str.size()<3)cout<<0<<endl,exit(0);
map<char,int> cnt;
for(int i=0;i<(int)str.size();i++)if(isalpha(str[i]))cnt[str[i]]++;
if(cnt.size()>8)cout<<0<<endl,exit(0);
int c = 0;
for(pair<char,int> p:cnt)if(isalpha(p.first)) M[p.first] = c++;
memset(ord,-1,sizeof(ord));
cout<<dfs(0,str)<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
string s[2];
string::iterator p;
int fact();
int term();
int exp();
int k;
bool f[2];
int fact() {
int x;string num;
int mi=1;
while(*p=='-') {
mi*=-1;
++p;
}
while(isdigit(*p)){num+=*p;++p;}
if(num.size()>1&&num[0]=='0') f[k]=0;
if(num.size()) {
x=0;
for(int i=num.size()-1,j=0; i>=0; i--,j++) x+=(1<<j)*(num[i]=='1');
} else if(p!=s[k].end()){
if(*p!='(') f[k]=0;
bool ff=(*p=='(');
if(p!=s[k].end()&&*p=='(')++p;
x=exp();
if(ff&&*p!=')') f[k]=0;
if(p!=s[k].end()&&*p==')')++p;
} else f[k]=0;
return x*mi;
}
int term() {
int x=fact();
while(*p=='*') {
++p;
x*=fact();
}
return x;
}
int exp() {
int x=term();
while(*p=='+'||*p=='-') {
if(*p=='+') {
++p;
x+=term();
} else {
++p;
x-=term();
}
}
return x;
}
int main() {
string r="01+-*()=";
sort(r.begin(),r.end());
string t;
cin >> t;
map<char,int> m;
for(int i=0; i<t.size(); i++) {
if(isalpha(t[i])&&!m.count(t[i])) {
int x=m.size();
m[t[i]]=x;
}
}
if(m.size()>r.size()) {
cout << 0 << endl;
return 0;
}
set<string> se;
do {
string e=t;
for(int i=0; i<e.size(); i++) {
if(isalpha(e[i])) e[i]=r[m[e[i]]];
}
int c=0;
for(int i=0; i<e.size(); i++) {
if(e[i]=='=') c++;
}
if(c!=1) continue;
c=0;
s[0]=s[1]="";
for(int i=0; i<e.size(); i++) {
if(e[i]=='=') {
c++;
continue;
}
s[c]+=e[i];
}
if(!s[0].size()||!s[1].size()) continue;
int x[2]={0,0};
for(k=0; k<2; k++) {
f[k]=1;
p=s[k].begin();
int d=0,z=0;
for(int i=0; i<s[k].size(); i++) {
if(isdigit(s[k][i])) z++;
if(s[k][i]=='(') {
d++;
if(i&&(isdigit(s[k][i-1])||s[k][i-1]==')')) f[k]=0;
if(i!=s[k].size()-1&&(!isdigit(s[k][i+1])&&s[k][i+1]!='('&&s[k][i+1]!='-')) f[k]=0;
}
if(s[k][i]==')') {
d--;
if(i&&(!isdigit(s[k][i-1])&&s[k][i-1]!=')')) f[k]=0;
if(i!=s[k].size()-1&&isdigit(s[k][i+1])) f[k]=0;
}
if(i) {
if(s[k][i]=='+'||s[k][i]=='*') {
if(s[k][i-1]=='+'||s[k][i-1]=='*'||s[k][i-1]=='-') f[k]=0;
}
} else if(s[k][i]=='+'||s[k][i]=='*') f[k]=0;
if(d<0) f[k]=0;
}
if(d||!z) f[k]=0;
if(f[k]) x[k]=exp();
}
if(f[0]&&f[1]&&x[0]==x[1]) {
se.insert(r.substr(0,m.size()));
}
} while(next_permutation(r.begin(),r.end()));
cout << se.size() << endl;
return 0;
} |
#include <bits/stdc++.h>
#define rep(i,N) for(int i=0;i<(int)N;i++)
#define rep1(i,N) for(int i=1;i<=(int)N;i++)
#define pb push_back
#define all(c) c.begin(),c.end()
#define show(x) cout<<#x<<" "<<x<<endl
using namespace std;
typedef long long ll;
const ll NO=1e15;
ll ex(const string& s,int& it);
ll dig(const string& s,int &it){
if(s[it]=='0'&&isdigit(s[it+1])) return NO;
ll x=0;
while(isdigit(s[it])){
x=x*2+s[it]-'0';
it++;
}
return x;
}
ll fac(const string& s,int& it){
if(isdigit(s[it])){
return dig(s,it);
}
if(s[it]=='-'){
it++;
ll ret=fac(s,it);
if(ret==NO) return NO;
return -ret;
}
if(s[it]=='('){
it++;
ll ret=ex(s,it);
if(ret==NO) return NO;
if(s[it]!=')') return NO;
it++;
return ret;
}
return NO;
}
ll term(const string& s,int& it){
ll ret=fac(s,it);
if(ret==NO) return NO;
while(s[it]=='*'){
it++;
ll x=fac(s,it);
if(x==NO) return NO;
ret*=x;
}
return ret;
}
ll ex(const string& s,int& it){
ll ret=term(s,it);
if(ret==NO) return NO;
while(s[it]=='+' || s[it]=='-'){
bool isp=(s[it]=='+');
it++;
ll x=term(s,it);
if(x==NO) return NO;
if(isp) ret+=x;
else ret-=x;
}
if(s[it]!=')' && s[it]!='$') return NO;
return ret;
}
bool eq(const string& s){
// cout<<s<<endl;
int N=s.size();
int e=-1;
rep(i,N){
if(s[i]=='='){
if(e==-1) e=i;
else return 0;
}
}
if(e==-1) return 0;
int it=0;
string X=s.substr(0,e)+"$";
ll x=ex(X,it);
if(X[it]!='$') x=NO;
if(x==NO) return 0;
it=0;
string Y=s.substr(e+1)+"$";
ll y=ex(Y,it);
if(Y[it]!='$') y=NO;
if(y==NO) return 0;
return x==y;
}
string S;
string rs="01+-*()=";
vector<char> cs;
int sel[8];
int K;
int ans;
void dfs(int d){
if(d==K){
string s=S;
rep(i,K){
rep(j,s.size()) if(s[j]==cs[i]) s[j]=rs[sel[i]];
}
if(eq(s)) ans++;
return;
}
rep(i,8){
bool canuse=1;
rep(j,d) if(sel[j]==i) canuse=0;
if(!canuse) continue;
sel[d]=i;
dfs(d+1);
}
}
int main(){
cin>>S;
rep(i,S.size()) if(isalpha(S[i])){
cs.pb(S[i]);
}
sort(all(cs));
cs.erase(unique(all(cs)),cs.end());
K=cs.size();
if(K>8){
puts("0");
return 0;
}
dfs(0);
cout<<ans<<endl;
} |
#include<bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define ALL(a) (a).begin(),(a).end()
pair<int, int> n(const string &s, int i) {
int nv = 0;
if (s[i] == '0') return make_pair(0, i+1);
if (!isdigit(s[i])) throw "invalid";
while (i < s.size() && isdigit(s[i])) {
nv *= 2;
nv += s[i] - '0';
++i;
}
return make_pair(nv, i);
}
pair<int, int> e(const string &s, int i);
pair<int, int> f(const string &s, int i) {
if (i >= s.size()) throw "invalid";
if (s[i] == '-') {
int fv;
tie(fv, i) = f(s, i+1);
return make_pair(-fv, i);
} else if (s[i] == '(') {
int ev;
tie(ev, i) = e(s, i+1);
if (i >= s.size() || s[i] != ')') throw "invalid";
return make_pair(ev, i+1);
}
return n(s, i);
}
pair<int, int> t(const string &s, int i) {
int fl;
tie(fl, i) = f(s, i);
while (i < s.size()-1 && s[i] == '*') {
int fr;
tie(fr, i) = f(s, i+1);
fl *= fr;
}
return make_pair(fl, i);
}
pair<int, int> e(const string &s, int i) {
int tl;
tie(tl, i) = t(s, i);
while (i < s.size()-1 && (s[i] == '+' || s[i] == '-')) {
char op = s[i];
int tr;
tie(tr, i) = t(s, i+1);
if (op == '+') {
tl += tr;
} else {
tl -= tr;
}
}
return make_pair(tl, i);
}
bool valid(const string &s) {
int i = 0;
int e1, e2;
tie(e1, i) = e(s, i);
if (i >= s.size() || s[i] != '=') throw "invalid";
tie(e2, i) = e(s, i+1);
if (i != s.size()) throw "invalid";
return e1 == e2;
}
int frac(int i) {
if (i == 0) return 1;
return i * frac(i-1);
}
int main(){
string ch = "01()+-=*";
sort(ALL(ch));
string s;
cin>>s;
int cnt=0;
vector<char> let;
for (char c : s) {
if (find(ALL(ch), c) == end(ch)) {
let.push_back(c);
}
}
sort(ALL(let));
let.erase(unique(ALL(let)), end(let));
if (let.size() > 8) {
cout << 0 << endl;
return 0;
}
map<char, int> idx;
REP(i,let.size()) {
idx[let[i]] = i;
}
do {
string t = s;
for (char &c : t) {
if (idx.count(c)) {
c = ch[idx[c]];
}
}
try {
if (valid(t)) {
++cnt;
}
} catch(...) {
}
} while (next_permutation(ALL(ch)));
cout << cnt/frac(ch.size() - let.size()) << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}
typedef pair<int, int> Pi;
typedef tuple<int, int, int> Ti;
typedef vector<int> vint;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
bool Q();
int E();
int T();
int F();
int N();
string B();
string enc;
string str;
string alpha;
int idx;
int ans;
bool flag;
string sign = "01+-*()=";
bool isok(char c) {
return idx < (int)str.size() && str[idx] == c;
}
bool Q() {
flag = true;
if(count(all(str), '=') != 1) return false;
int lh = E();
if(!flag) return false;
if(!isok('=')) return false;
idx++; // =
int rh = E();
if(!flag) return false;
if(idx != (int)str.size()) return false;
return lh == rh;
}
int E() {
int res = T();
if(!flag) return 0;
while(flag && (isok('+') || isok('-'))) {
int ope = (str[idx] == '+' ? 1 : -1);
idx++; // +/-
int ri = T();
if(!flag) return 0;
res += ope*ri;
}
return res;
}
int T() {
int res = F();
if(!flag) return 0;
while(flag && isok('*')) {
idx++;
int ri = F();
if(!flag) return 0;
res *= ri;
}
return res;
}
int F() {
if(isok('-')) {
idx++;
int res = F();
if(!flag) return 0;
return -res;
}
if(isok('(')) {
idx++;
int res = E();
if(!flag) return 0;
if(!isok(')')) { flag = false; return 0; }
idx++; // )
return res;
}
int res = N();
if(!flag) return 0;
return res;
}
int N() {
string tmp = B();
if(tmp.empty() || (tmp.size() > 1 && tmp[0] == '0')) { flag = false; return 0; }
reverse(all(tmp));
int res = 0, p = 1;
rep(i, tmp.size()) {
res += (tmp[i]-'0')*p;
p *= 2;
}
return res;
}
string B() {
string res = "";
while(idx < (int)str.size() && isdigit(str[idx])) res += str[idx++];
return res;
}
signed main()
{
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
cin >> enc;
for(char c : enc) {
if(isalpha(c)) alpha.push_back(c);
}
sort(all(alpha));
alpha.erase(unique(all(alpha)), alpha.end());
if(alpha.size() > sign.size()) {
cout << 0 << endl;
return 0;
}
ans = 0;
sort(all(sign));
set<string> st;
do {
//cout<<sign<<endl;
idx = 0;
str = enc;
for(char &c : str) {
if(isalpha(c)) c = sign[alpha.find(c)];
}
if(st.count(str)) continue;
st.insert(str);
if(Q()) {
//cout << idx << " " << str << endl;
ans++;
}
} while(next_permutation(all(sign)));
cout << ans << endl;
return 0;
} |
#include <cstdio>
#include <cstdint>
#include <cctype>
#include <cassert>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <stdexcept>
const std::string TERMINAL = "01+-*()=";
const std::vector<std::string> OPS = {"+-", "*"};
int parse(const std::string& s, size_t& i, size_t preced=0) {
if (preced == OPS.size()) {
if (s[i] == '(') {
int res = parse(s, ++i, 0);
if (s[i] != ')') throw std::logic_error("expected: closing parenthesis");
++i;
return res;
}
if (s[i] == '-') {
return -parse(s, ++i, preced);
}
if (s[i] == '0') {
++i;
if (isdigit(s[i]))
throw std::logic_error("expected: leading-zero-free number");
return 0;
}
if (isdigit(s[i])) {
int res = s[i]-'0';
while (++i < s.length() && isdigit(s[i]))
res = res*2 + s[i]-'0';
return res;
}
throw std::logic_error("unexpected token");
}
int lhs = parse(s, i, preced+1);
while (i < s.length()) {
char op = s[i];
if (!std::count(OPS[preced].begin(), OPS[preced].end(), op)) break;
int rhs = parse(s, ++i, preced+1);
if (op == '+') lhs += rhs;
if (op == '-') lhs -= rhs;
if (op == '*') lhs *= rhs;
}
return lhs;
}
void validate(const std::string& s) {
size_t i = 0;
int lhs = parse(s, i);
if (s[i] != '=') throw std::logic_error("excepted: equal sign");
++i;
int rhs = parse(s, i);
if (i != s.length()) throw std::logic_error("expected: EOL");
if (lhs != rhs) throw std::logic_error("not equal");
// validated
}
int main() {
char buf[32];
scanf("%s", buf);
std::string s = buf;
std::set<char> alpha;
for (char ch: s)
if (isalpha(ch)) alpha.insert(ch);
if (alpha.size() > TERMINAL.size())
return puts("0"), 0;
std::vector<char> t;
for (char ch: TERMINAL) t.push_back(ch);
std::sort(t.begin(), t.end());
std::set<std::string> eq;
do {
std::map<char, char> enc;
{
size_t i = 0;
for (auto it=alpha.begin(); it!=alpha.end(); ++it)
enc[*it] = t[i++];
}
std::string s1 = s;
for (char &c: s1)
if (isalpha(c)) c = enc[c];
try {
validate(s1);
eq.insert(s1);
} catch (std::logic_error&) {
void(0);
}
} while (std::next_permutation(t.begin() ,t.end()));
printf("%zu\n", eq.size());
}
|
#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
#define int long long
using namespace std;
typedef pair<int,int>P;
bool OK(string s){
int cnt=0;
for(int i=0;i<s.size();i++){
if(s[i]=='-'){
if(i+1==s.size())return 0;
if(s[i+1]=='+')return 0;
if(s[i+1]=='*')return 0;
if(i&&s[i-1]=='('&&s[i+1]==')')return 0;
if(s[i+1]==')')return 0;
}
if(s[i]=='+'){
if(i==0)return 0;
if(i+1==s.size())return 0;
if(s[i+1]=='+')return 0;
//if(s[i+1]=='-')return 0;
if(s[i+1]=='*')return 0;
if(s[i+1]==')')return 0;
}
if(s[i]=='*'){
if(i==0)return 0;
if(i+1==s.size())return 0;
if(s[i+1]=='+')return 0;
//if(s[i+1]=='-')return 0;
if(s[i+1]=='*')return 0;
if(s[i+1]==')')return 0;
}
if(isdigit(s[i])){
if(i&&s[i-1]==')')return 0;
if(s[i]=='0'){
if(i==0&&isdigit(s[i+1]))return 0;
if(i&&i<s.size()&&!isdigit(s[i-1])&&isdigit(s[i+1]))return 0;
}
if(s[i+1]=='(')return 0;
}
if(s[i]=='('){
cnt++;
if(i==s.size())return 0;
if(s[i+1]=='+')return 0;
if(s[i+1]=='*')return 0;
if(s[i+1]==')')return 0;
}
if(s[i]==')'){
cnt--;
if(cnt<0)return 0;
if(!i)return 0;
if(isdigit(s[i+1]))return 0;
if(s[i+1]=='(')return 0;
}
}
if(cnt)return 0;
return 1;
}
string str,s;
set<char>st;
struct Parse{
string s;
int p;
int g_A(){
int r=0,x=1;
if(s[p]=='-'){
p++;
return -g_A();
}
else if(s[p]=='(')p++,r=bnf1(),p++;
else while(isdigit(s[p])) r=r*2+(s[p++]-'0');
return r;
}
int bnf2(){
int res=g_A();
while(s[p]=='*'){
int t=p++;
if(s[t]=='*')res*=g_A();
}
return res;
}
int bnf1(){
int res=bnf2();
while(s[p]=='+'||s[p]=='-'){
int t=p++;
if(s[t]=='+')res+=bnf2();
if(s[t]=='-')res-=bnf2();
}
return res;
}
int build(string t){
p=0;
s=t;
return bnf1();
}
};
int ans=0;
string t="01()+*-=";
map<char,int>M1;
int n;
signed main(){
Parse p;
cin>>s;
r(i,s.size())if(isalpha(s[i]))st.insert(s[i]);
n=st.size();
int cc=0;
for(set<char>::iterator it=st.begin();it!=st.end();it++){
char c=*it;
M1[c]=cc++;
}
set<string>S;
vector<int>v;
r(i,8)v.push_back(i);
do{
int sum=0,idx;
string x=s;
r(i,x.size()){
if(isalpha(x[i])){
int y=M1[x[i]];
x[i]=t[v[y]];
}
}
if(S.count(x))continue;
r(i,x.size())if(x[i]=='=')sum++,idx=i;
if(sum!=1)continue;
if(idx==0||idx==x.size()-1)continue;
string a=x.substr(0,idx);
string b=x.substr(idx+1);
if(!OK(a)||!OK(b))continue;
int A=p.build(a);
int B=p.build(b);
if(A==B){
S.insert(x);
ans++;
}
}while(next_permutation(v.begin(),v.end()));
cout<<ans<<endl;
}
|
#include<iostream>
#include<cstdio>
#include<vector>
#include<sstream>
#include<deque>
#include<algorithm>
#include<map>
#include<set>
#include<cstdlib>
#include<climits>
#include<cassert>
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define all(x) x.begin(),x.end()
using namespace std;
typedef long long ll;
const ll LLINF = LLONG_MAX;
const bool debug = false;
const string opr = "01+-*=()";
string context;
int n;
ll parse_E(int&,string&);
ll parse_F(int &p,string &s) {
if( p >= (int)s.size() ) return LLINF;
if( s[p] == '+' ) return LLINF;
if( s[p] == '-' ) {
++p;
ll v = parse_F(p,s);
if( v == LLINF ) return LLINF;
return v * -1LL;
}
if( s[p] == '(' ) {
++p;
ll v = parse_E(p,s);
if( v == LLINF ) return LLINF;
if( p >= (int)s.size() ) return LLINF;
if( s[p] != ')' ) return LLINF;
++p;
if( p < (int)s.size() && ( s[p] == '0' || s[p] == '1' ) ) return LLINF;
return v;
}
int cnt = 0;
ll v = 0;
bool first_zero = ( s[p] == '0' );
while( p < (int)s.size() && ( s[p] == '0' || s[p] == '1' ) ) {
v <<= 1;
v += (ll)( s[p] - '0' );
++p;
++cnt;
}
if( first_zero && cnt != 1 ) return LLINF;
if( cnt == 0 ) return LLINF;
if( p < (int)s.size() && s[p] == '(' ) return LLINF;
return v;
}
ll parse_T(int &p,string &s) {
ll v = parse_F(p,s);
if( v == LLINF ) return v;
while( p < (int)s.size() && s[p] == '*' ) {
++p;
ll tmp = parse_T(p,s);
if( tmp == LLINF ) return tmp;
v *= tmp;
}
return v;
}
ll parse_E(int &p,string &s) {
ll v = parse_T(p,s);
if( v == LLINF ) return v;
while( p < (int)s.size() && ( s[p] == '+' || s[p] == '-' ) ) {
char op = s[p];
++p;
ll tmp = parse_T(p,s);
if( tmp == LLINF ) return tmp;
if( op == '+' ) v += tmp;
if( op == '-' ) v -= tmp;
}
return v;
}
bool pari_check(string &s) {
int cnt = 0;
rep(i,(int)s.size()) {
if( s[i] == '(' ) ++cnt;
if( s[i] == ')' ) --cnt;
if( cnt < 0 ) return false;
}
return cnt == 0;
}
bool check() {
string s,t;
{
string tmp;
tmp = context;
rep(i,n) if( context[i] == '=' ) tmp[i] = ' ';
vector<string> vec;
stringstream ss;
ss << tmp;
while( ss >> s ) vec.push_back(s);
if( vec.size() != 2 ) return false;
s = vec[0];
t = vec[1];
}
if( !pari_check(s) || !pari_check(t) ) return false;
int p = 0;
ll sv = parse_E(p,s);
p = 0;
ll tv = parse_E(p,t);
if( sv == LLINF || tv == LLINF) return false;
return sv == tv;
}
int dfs(int ptr,int used,vector<char> &already) {
if( n <= ptr ) {
if( debug ) {
if( check() ) {
cout << "succeeded : " << context << endl;
return true;
} else {
//cout << "failed : " << context << endl;
return false;
}
} else {
return check();
}
}
if( !isalpha(context[ptr]) ) return dfs(ptr+1,used,already);
int sum = 0;
int v = context[ptr] - 'a';
if( already[v] != '$' ) {
if( already[v] == '=' ) return 0;
char tmp = context[ptr];
context[ptr] = already[v];
sum += dfs(ptr+1,used,already);
context[ptr] = tmp;
return sum;
}
rep(i,(int)opr.size()) {
if( ( used >> i ) & 1 ) continue;
char tmp = context[ptr];
context[ptr] = opr[i];
already[v] = opr[i];
sum += dfs(ptr+1,used|(1<<i),already);
already[v] = '$';
context[ptr] = tmp;
}
return sum;
}
bool normalize() {
vector<char> vec;
rep(i,(int)context.size()) if( isalpha(context[i]) ) vec.push_back(context[i]);
sort(all(vec));
vec.erase(unique(all(vec)),vec.end());
rep(i,(int)context.size()) if( isalpha(context[i]) ) {
int pos = lower_bound(all(vec),context[i]) - vec.begin();
context[i] = (char)('a'+pos);
}
return (int)vec.size() <= 8;
}
void compute() {
if( debug ) cout << " context : " << context << endl;
if( !normalize() ) { puts("0"); return; }
if( debug ) cout << "fixed context : " << context << endl;
n = (int)context.size();
int used = 0;
rep(i,n) if( context[i] == '=' ) { used = (1<<5); break; }
vector<char> vec(8,'$');
cout << dfs(0,used,vec) << endl;
}
int main() {
if( 0 ) {
string s;
cin >> s;
int p = 0;
cout << parse_E(p,s) << endl;
return 0;
}
cin >> context;
compute();
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb push_back
#define INF (1e9+1)
//#define INF (1LL<<59)
typedef string::const_iterator State;
int ans;
string s;
ll exp(State &begin);
ll bin(State &begin){
ll ret=0;
while(isdigit(*begin)){
ret*=2;
ret+=*begin-'0';
begin++;
}
return ret;
}
ll number(State &begin){
if(*begin=='0'){
begin++;
if(isdigit(*begin))throw "number error1";
else return 0;
}
else if(*begin=='1'){
return bin(begin);
}else throw "number error2";
assert(1);
return -1;
}
ll factor(State &begin){
if( isdigit(*begin) )return number(begin);
else if(*begin=='-'){
begin++;
if(isdigit(*begin)||*begin=='('||*begin=='-') return -1*factor(begin);
else throw "factor error1";
}else if(*begin=='('){
begin++;
ll ret = exp(begin);
if(*begin!=')')throw "factor error2";
begin++;
return ret;
}
else throw "factor error3";
assert(1);
return -1;
}
ll term(State &begin){
ll ret = factor(begin);
if(*begin=='+'||*begin=='-'||*begin=='$'||*begin==')'){
return ret;
}
else if(*begin=='*'){
begin++;
return ret*term(begin);
}
else throw "term error";
assert(1);
return -1;
}
ll exp(State &begin){
ll ret = term(begin);
while(1){
if(*begin=='+'){
begin++;
ret+=term(begin);
}else if(*begin=='-'){
begin++;
ret-=term(begin);
}else if(*begin=='$'||*begin==')'){
return ret;
}else throw "exp error";
}
assert(1);
return -1;
}
bool isValid(string tmp){
int eqc=0;
rep(i,tmp.size())if(tmp[i]=='=')eqc++;
if(eqc!=1)return false;
string str[2]={};
bool f=false;
rep(i,tmp.size()){
if(tmp[i]=='=')f=true;
else if(f)str[1]+=tmp[i];
else str[0]+=tmp[i];
}
if(str[0].size()==0||str[1].size()==0)return false;
State b[2];
ll res[2];
try{
rep(i,2){
str[i] +='$';
b[i] = str[i].begin();
res[i] = exp(b[i]);
}
}catch(char const* e){
return false;
}
if(res[0]==res[1] && *b[0]=='$'&&*b[1]=='$'){
return true;
}else return false;
}
void dfs(string tmp,vector<bool> used){
char alp='!';
int pos=-1;
rep(i,tmp.size()){
if(isalpha(tmp[i]))alp=tmp[i],pos=i;
}
if(pos==-1){ if(isValid(tmp))ans++; return; }
assert(alp!='!');
string symbols = "01+-*()=";
rep(i,symbols.size()){
if(used[i])continue;
used[i]=true;
string ntmp = tmp;
rep(j,ntmp.size()){
if(ntmp[j]==alp) ntmp[j] = symbols[i];
}
dfs(ntmp,used);
used[i]=false;
}
}
int main(){
cin>>s;
set<char> st;
vector<char> vs;
rep(i,s.size())st.insert(s[i]);
for(auto &e:st)vs.pb(e);
int count=0;
rep(i,vs.size())if(isalpha(vs[i]))count++;
if(count>8){
cout<<0<<endl;
return 0;
}
ans=0;
vector<bool> used(8,false);
dfs(s,used);
cout<<ans<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define REP(i,n) for(int i = 0; i < (int)(n); ++i)
#define DEBUG(x) cerr << #x << " = " << x << endl
pair<string, string> split(const string &s) {
int p = s.find('=');
string l = s.substr(0, p);
string r = s.substr(p + 1);
return make_pair(l, r);
}
bool check(const string &s) {
int p = s.find('=');
if(p == -1) return false;
pair<string, string> sp = split(s);
if(sp.first.size() == 0 || sp.second.size() == 0) return false;
int k = 0;
for(char c : sp.first) {
if(c == '(') ++k;
if(c == ')') --k;
if(k < 0) return false;
}
if(k != 0) return false;
for(char c : sp.second) {
if(c == '(') ++k;
if(c == ')') --k;
if(k < 0) return false;
}
return true;
}
typedef string::const_iterator iter;
struct Result {
bool valid;
int value;
Result(bool valid_, int value_) : valid(valid_), value(value_) {}
};
Result fail(false, 114514);
bool Q(iter &p);
Result E(iter &p);
Result T(iter &p);
Result F(iter &p);
Result N(iter &p);
Result B(iter &p);
bool Q(iter &p) {
Result l = E(p);
// if(!l.valid) {
// cerr << "l = No" << endl;
// }
// else {
// cerr << "l = " << l.value << endl;
// }
if(!l.valid) return false;
if(*p != '=') return false;
++p;
Result r = E(p);
// if(!l.valid) {
// cerr << "r = No" << endl;
// }
// else {
// cerr << "r = " << r.value << endl;
// }
if(!r.valid) return false;
if(*p != '\0') return false;
return l.value == r.value;
}
Result E(iter &p) {
Result t = T(p);
if(!t.valid) return fail;
while(true) {
if(*p == '+') {
++p;
Result s = T(p);
if(!s.valid) return fail;
t.value += s.value;
}
else if(*p == '-') {
++p;
Result s = T(p);
if(!s.valid) return fail;
t.value -= s.value;
}
else {
break;
}
}
return t;
}
Result T(iter &p) {
Result t = F(p);
if(!t.valid) return fail;
while(true) {
if(*p == '*') {
++p;
Result s = F(p);
if(!s.valid) return fail;
t.value *= s.value;
}
else {
break;
}
}
return t;
}
Result F(iter &p) {
if(*p == '(') {
++p;
Result e = E(p);
if(*p != ')') {
return fail;
}
++p;
return e;
}
else if(*p == '-') {
++p;
Result e = F(p);
if(!e.valid) return fail;
e.value *= -1;
return e;
}
return N(p);
}
Result N(iter &p) {
if(!isdigit(*p)) {
return fail;
}
int n = 0;
int i = 0;
while(isdigit(*p)) {
n *= 2;
if(i > 0 && n == 0) return fail;
n += *p - '0';
++p;
++i;
}
// DEBUG(n);
return Result(true, n);
}
void dbg() {
string S; cin >> S;
iter p = S.cbegin();
bool r = Q(p);
cout << (r ? "Yes" : "No") << endl;
}
signed main() {
ios::sync_with_stdio(false);
if(false) {
dbg();
}
else {
string S; cin >> S;
vector<char> ch;
string ops = "01+-*=()";
sort(ops.begin(), ops.end());
REP(i,S.size()) {
if(ops.find(S[i]) == string::npos) {
ch.push_back(S[i]);
}
}
sort(ch.begin(), ch.end());
ch.erase(unique(ch.begin(), ch.end()), ch.end());
if(ch.size() > 8) {
cout << 0 << endl;
return 0;
}
map<char, int> replacer;
REP(i,ch.size()) {
replacer[ch[i]] = i;
// DEBUG(ch[i]);
}
set<string> ans;
do {
string T = S;
REP(i,T.size()) {
if(replacer.count(T[i])) T[i] = ops[replacer[T[i]]];
}
// if(T == "-0=(0)") DEBUG(T);
iter p = T.cbegin();
bool r = Q(p);
if(r) {
ans.insert(ops.substr(0,ch.size()));
// DEBUG(T);
}
} while(next_permutation(ops.begin(), ops.end()));
cout << ans.size() << endl;
}
} |
#include<bits/stdc++.h>
using namespace std;
char moji[] = "01+-*()=";
string s;
char cset[100];
int idx[100];
int length;
vector<int> perm;
int pos;
bool correct;
string currents;
char get(int i){
if(i >= length){
return '\0';
}
return currents[i];
}
bool Q();
int E();
int T();
int F();
int N();
int B(int cur);
bool Q(){
int a = E();
if(get(pos) != '='){
correct = false;
return false;
}
pos++;
int b = E();
return a == b;
}
int E(){
int t = T();
while(get(pos) == '+' || get(pos) == '-'){
if(get(pos) == '+'){
pos++;
t += T();
}else{
pos++;
t -= T();
}
}
return t;
}
int T(){
int f = F();
while(get(pos) == '*'){
pos++;
f *= F();
}
return f;
}
int F(){
if(get(pos) == '-'){
pos++;
return - F();
}
if(get(pos) == '('){
pos++;
int e = E();
if(get(pos) != ')'){
correct = false;
}
pos++;
return e;
}
return N();
}
int N(){
if(get(pos) == '0'){
pos++;
return 0;
}
if(get(pos) == '1'){
pos++;
return B(1);
}
correct = false;
return 0;
}
int B(int cur){
if(get(pos) == '0'){
pos++;
return B(cur * 2);
}
if(get(pos) == '1'){
pos++;
return B(cur * 2 + 1);
}
return cur;
}
int main(){
cin >> s;
length = s.size();
int si = 0;
for(int i = 0; i < s.size(); i++){
if(!(('a' <= s[i] && s[i] <= 'z') || ('A' <= s[i] && s[i] <= 'Z'))){
idx[i] = s[i];
continue;
}
int j;
for(j = 0; j < si; j++){
if(cset[j] == s[i]) break;
}
if(j == si){
si++;
if(si > 8){
cout << 0 << endl;
return 0;
}
cset[j] = s[i];
}
idx[i] = j;
}
for(int i = 0 ; i < 8; i++){
perm.push_back(i);
}
set<string> smap;
do{
string ns = s;
for(int i = 0; i < ns.size(); i++){
if(('a' <= s[i] && s[i] <= 'z') || ('A' <= s[i] && s[i] <= 'Z')){
ns[i] = moji[perm[idx[i]]];
}
}
smap.insert(ns);
}while(next_permutation(perm.begin(), perm.end()));
int ans = 0;
for(string ss : smap){
currents = ss;
pos = 0;
correct = true;
if(Q() && correct && pos == ss.size()){
ans++;
}
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; ++ i)
using namespace std;
void Q();
int E();
int T();
int F();
int N();
int B();
int m;
string s;
size_t cur;
bool failed;
//Q::=E=E
void Q(){
cur = 0,failed = 0;
m = s.size();
int l = E();
if(s[cur]!='=') failed = 1;
cur++;
int r = E();
if(cur != m or l != r) failed = 1;
}
// E::=T|E+T|E???T
int E(){
int res = T();
while(cur < m and s[cur] == '+' or s[cur] == '-'){
char op = s[cur];
cur++;
const int arg = T();
if(op == '+')
res += arg;
else
res -= arg;
}
return res;
}
// T::=F|T???F
int T(){
int res = F();
while(cur < m and s[cur] == '*'){
cur++;
const int arg = F();
res *= arg;
}
return res;
}
// F::=N|???F|(E)
int F(){
if(cur < m and isdigit(s[cur])){
return N();
}else if(cur < m and s[cur]=='-'){
cur++;
return -F();
}else if(cur < m and s[cur]=='('){
cur++;
const int res = E();
if(s[cur]!=')') failed = true;
cur++;
return res;
}else{
failed = true;
return 0;
}
}
// N::=0|1B
int N(){
if(cur < m and s[cur]=='0'){
cur++;
return 0;
}else if(cur < m and s[cur]=='1'){
cur++;
return B();
}else{
failed = true;
return 0;
}
}
// B::=??|0B|1B
int B(){
int res = 1;
while(cur < m and isdigit(s[cur])){
res = 2 * res + (s[cur] - '0');
cur++;
}
//cerr << res << endl;
return res;
}
char letter[8] = {'0','1','+','-','*','(',')','='};
int main(void){
string t;
cin >> t;
const int n = t.size();
vector<char> ary;
rep(i,n) if(isalpha(t[i])) ary.push_back(t[i]);
sort(begin(ary),end(ary));
ary.erase(unique(begin(ary),end(ary)),end(ary));
const int l = ary.size();
if(l > 8){
cout << 0 << endl;
return 0;
}
set<string> eq;
sort(letter,letter+8);
do{
string nt = t;
rep(i,n){
if(isalpha(nt[i])){
rep(j,l) if(nt[i] == ary[j]) nt[i] = letter[j];
}
}
eq.insert(nt);
}while(next_permutation(letter,letter+8));
int ans = 0;
for(auto &it:eq){
//cerr << it << endl;
s = it;
Q();
ans += (failed == 0);
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef pair<string,string> P;
int bnf();
set<P> used;
map<char,int> M;
string S;
int idx,valid;
char ch[8]={'0','1','+','-','*','(',')','='};
int ord[8];
bool check(string a){//?????????????????°??¨??????????????????????¢????
int par=0;
for(char s:a){
par += (s == '(') - (s == ')');
if(s == '=') return 0;
if(par < 0) return 0;
}
return par==0;
}
int getNum(){ //??????????????°????????????
int res = 0;
if(S[idx] == '0' && isdigit(S[idx+1])) valid = 0;
while(isdigit(S[idx]))res = res*2 + S[idx++]-'0';
return res;
}
int cal(){
char ch = S[idx];
int res = 0,sign = 1;
if(ch=='+'||ch=='*'||ch==')'){ valid = 0;return 0;}
while(S[idx] == '-') idx++, sign *= -1;
ch = S[idx];
if(isdigit(ch)){
res = sign*getNum();
if(S[idx] == '*'){idx++; return res * cal();}
return res;
}
else if(ch == '(') {
idx++;res = sign*bnf();idx++;
return res;
}
valid = 0;
return 0;
}
int bnf(){
int res = cal();
while(idx<(int)S.size()){
if(valid == 0) return -1;
char ch = S[idx];
if(ch == '('){valid = 0;}
else if(ch == '*'){idx++;res *= cal();}
else if(ch == '+'){idx++;res += cal();}
else if(ch == '-'){idx++;res -= cal();}
else if(ch != ')') valid = 0;
else break;
}
if(valid ==0) return -1;
return res;
}
string mkS(string a){
string res;
for(char s:a){
if(isalpha(s))res += ch[ ord[ M[s] ] ];
else res += s;
}
return res;
}
int calc(string A,string B){
if(A.size()==0 || B.size()==0) return 0;
if(used.count(P(A,B)))return 0;
used.insert(P(A,B));
valid = check(A) && check(B);
idx = 0;
S = A;
int ra = bnf();
idx = 0;
S = B;
int rb = bnf();
//if(valid)cout<<A<<"="<<B<<" "<<valid<<" "<<ra<<" "<<rb<<endl;
return ra == rb && valid;
}
int calc(string s){
s = mkS(s);
for(int i=0;i<(int)s.size();i++)
if(s[i]=='=') return calc(s.substr(0,i),s.substr(i+1,s.size()-i-1));
return 0;
}
int dfs(int num,string &s){
if(num == 8) return calc(s);
int res = 0;
for(int i=0;i<8;i++){
if(ord[i] != -1)continue;
ord[i] = num;
res +=dfs(num+1,s);
ord[i] = -1;
}
return res;
}
int main(){
string str;
cin>>str;
if(str.size()<3)cout<<0<<endl,exit(0);
map<char,int> cnt;
for(int i=0;i<(int)str.size();i++)if(isalpha(str[i]))cnt[str[i]]++;
if(cnt.size()>8)cout<<0<<endl,exit(0);
int c = 0;
for(pair<char,int> p:cnt)if(isalpha(p.first)) M[p.first] = c++;
memset(ord,-1,sizeof(ord));
cout<<dfs(0,str)<<endl;
return 0;
} |
#include <algorithm>
#include <cctype>
#include <cstdint>
#include <iostream>
#include <map>
#include <numeric>
#include <stdexcept>
#include <string>
#include <utility>
using Num = std::int64_t;
class Solver {
public:
std::string s;
Num solve() {
std::map<char, int> char_idx;
std::string symbols = "=+-*01()";
Num num = 0;
for (auto c : s) {
if (std::isalpha(c) and char_idx.count(c) == 0) {
int x = char_idx.size();
char_idx[c] = x;
}
}
if (char_idx.size() > 8) return 0;
s_ = s;
s_.push_back('\0');
std::sort(symbols.begin(), symbols.end());
do {
for (std::size_t i = 0; i < s_.size(); ++i) {
s_[i] = (isalpha(s[i])? symbols[char_idx[s[i]]]: s[i]);
}
if (eval_q()) ++num;
std::reverse(symbols.begin() + char_idx.size(), symbols.end());
} while (std::next_permutation(symbols.begin(), symbols.end()));
return num;
}
private:
std::string s_;
bool eval_q() {
// std::cerr << "TRY: " << s_ << std::endl;
try {
std::size_t i = 0;
Num left, right;
left = eval_e(i);
if (s_[i] != '=') throw std::runtime_error("left");
++i;
right = eval_e(i);
if (i < s.size()) throw std::runtime_error("right");
// std::cerr << left << (left == right? " == ": " != ") << right << std::endl;
return left == right;
} catch (std::runtime_error &e) {
// std::cerr << "FAIL: " << e.what() << std::endl;
return false;
}
}
Num eval_e(std::size_t &i) {
Num n = eval_t(i);
while (i < s.size()) {
if (s_[i] == '+') {
++i;
n += eval_t(i);
} else if (s_[i] == '-') {
++i;
n -= eval_t(i);
} else {
break;
}
}
return n;
}
Num eval_t(std::size_t &i) {
Num n = eval_f(i);
while (s_[i] == '*') {
++i;
n *= eval_f(i);
}
return n;
}
Num eval_f(std::size_t &i) {
Num n;
if (s_[i] == '-') {
++i;
n = -eval_f(i);
} else if (s_[i] == '(') {
++i;
n = eval_e(i);
if (s_[i] != ')') throw std::runtime_error(")");
++i;
} else {
n = eval_n(i);
}
return n;
}
Num eval_n(std::size_t &i) {
if (s_[i] == '0' or s_[i] == '1') {
Num n = s_[i] - '0';
++i;
if (n == 0 and (s_[i] == '0' or s_[i] == '1')) throw std::runtime_error("leading zero");
while (true) {
if (s_[i] == '0' or s_[i] == '1') {
n = 2 * n + s_[i] - '0';
++i;
} else {
break;
}
}
return n;
} else {
throw std::runtime_error("N");
}
}
};
int main() {
Solver s;
std::cin >> s.s;
std::cout << s.solve() << std::endl;
return 0;
} |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#define llint long long
using namespace std;
llint readE();
string s, t;
vector<char> vec;
llint pos;
bool err;
llint readN()
{
if(t[pos] == '0'){
pos++;
return 0;
}
if(t[pos] != '1'){
err = true;
return 0;
}
llint ret = 0;
while(t[pos] == '0' || t[pos] == '1'){
ret *= 2;
ret += t[pos] - '0';
pos++;
}
return ret;
}
llint readF()
{
if(t[pos] == '-'){
pos++;
return -readF();
}
else if(t[pos] == '('){
pos++;
int ret = readE();
if(t[pos] == ')'){
pos++;
return ret;
}
err = true;
return 0;
}
else if(t[pos] == '0' || t[pos] == '1') return readN();
err = true;
return 0;
}
llint readT()
{
llint ret = 1;
while(1){
ret *= readF();
if(t[pos] == '*') pos++;
else return ret;
}
}
llint readE()
{
llint ret = 0, sgn = 1;
while(1){
ret += sgn * readT();
if(t[pos] == '+'){
pos++;
sgn = 1;
}
else if(t[pos] == '-'){
pos++;
sgn = -1;
}
else return ret;
}
}
bool readQ()
{
llint l = readE();
if(t[pos] != '='){
err = true;
return false;
}
pos++;
llint r = readE();
if(t[pos] != '#'){
err = true;
return false;
}
return l == r;
}
int main(void)
{
cin >> s;
s += "#";
for(int i = 0; i < s.size(); i++){
if(s[i] >= 'A' && s[i] <= 'Z' || s[i] >= 'a' && s[i] <= 'z') vec.push_back(s[i]);
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
int C = vec.size();
if(C > 8){
cout << 0 << endl;
return 0;
}
for(int i = 0; i < s.size(); i++){
if(s[i] >= 'A' && s[i] <= 'Z' || s[i] >= 'a' && s[i] <= 'z'){
s[i] = (int)(lower_bound(vec.begin(), vec.end(), s[i]) - vec.begin()) + 'a';
}
}
llint ans = 0;
llint perm[8];
for(int i = 0; i < 8; i++) perm[i] = i;
const char c[] = {'0', '1', '+', '-', '*', '=', '(', ')'};
t = s;
do{
for(int i = 0; i < s.size(); i++){
if(s[i] >= 'a' && s[i] <= 'z') t[i] = c[perm[s[i]-'a']];
else t[i] = s[i];
}
pos = 0;
err = false;
if(readQ() && !err) ans++;
}while(next_permutation(perm, perm+8));
llint div = 1;
for(int i = 1; i <= 8-C; i++) div *= i;
cout << ans / div << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
struct Parser{
string s;
int N;
int c;
ll parse(string s){
this->s = s;
N = s.size();
c = 0;
try{
ll ret = expr();
if(c != N) throw "";
return ret;
}
catch(...){
return INF;
}
}
void debug(string text){
return;
cout << text + " ";
for(int i = 0; i < N; i++){
if(i == c) cout << '[' << s[i] << ']';
else cout << s[i];
}
cout << endl;
}
ll expr(){
debug("expr");
ll x = term();
while(c < N){
if(s[c] == '+'){
c++;
x += term();
}
else if(s[c] == '-'){
c++;
x -= term();
}
else break;
}
return x;
}
ll term(){
debug("term");
ll x = factor();
while(c < N){
if(s[c] == '*'){
c++;
x *= factor();
}
else break;
}
return x;
}
ll factor(){
debug("factor");
if(s[c] == '-'){
c++;
return -factor();
}
if(s[c] == '('){
c++;
ll ret = expr();
if(s[c] != ')') throw "";
//assert(s[c] == ')');
c++;
return ret;
}
return num();
}
ll num(){
debug("num");
if(!isdigit(s[c])) throw "";
ll ret = 0;
string digit;
while(c < N && isdigit(s[c])){
ret = ret * 2 + s[c] - '0';
digit += s[c];
c++;
}
if(digit != "0" && digit[0] == '0') throw "";
return ret;
}
} parser;
string s;
int ans;
vector<char> cs;
string op = "01+-*()=";
int used[10];
map<char, char> m;
void dfs(int n){
if(n == cs.size()){
string t = s;
for(int i = 0; i < t.size(); i++){
if(m.count(t[i])) t[i] = m[t[i]];
}
int eq = t.find('=');
if(eq == string::npos) return;
string e1 = t.substr(0, eq);
string e2 = t.substr(eq + 1);
if(e1 == "" || e2 == "") return;
ll res1 = parser.parse(e1), res2 = parser.parse(e2);
if(res1 != INF && res2 != INF && res1 == res2){
ans++;
}
return;
}
for(int i = 0; i < op.size(); i++){
if(used[i]) continue;
used[i] = 1;
m[cs[n]] = op[i];
dfs(n + 1);
used[i] = 0;
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef LOCAL
std::ifstream in("in");
std::cin.rdbuf(in.rdbuf());
#endif
while(cin >> s){
cs.clear();
for(auto c : s){
if(isalpha(c)) cs.push_back(c);
}
sort(cs.begin(), cs.end());
cs.erase(unique(cs.begin(), cs.end()), cs.end());
m.clear();
ans = 0;
dfs(0);
//cout << s << endl;
cout << ans << endl;
}
} |
#include <bits/stdc++.h>
#include <stdexcept>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
string S;
int idx;
int N, M;
string alphas;
int curr;
void consume(char c) {
if(idx >= N) throw exception();
if(S[idx] != c) throw exception();
idx ++;
}
bool try_consume(char c) {
try {
consume(c);
} catch(exception e) {
return false;
}
return true;
}
int E();
int convert(string const& b) {
int n = b.size();
int ret = 0;
for(int i=0; i<n; i++) {
ret *= 2;
assert(isdigit(b[i]));
ret += b[i] - '0';
}
return ret;
}
string B() {
string ret;
while(1) {
if(S[idx] == '0') ret += '0';
else if(S[idx] == '1') ret += '1';
else break;
idx++;
}
return ret;
}
int Nu() {
if(try_consume('0')) return 0;
consume('1');
return convert("1" + B());
}
int F() {
if(try_consume('-')) {
return -F();
}
else if(try_consume('(')) {
int r = E();
consume(')');
return r;
}
else {
return Nu();
}
}
int T() {
int num1 = F();
while(try_consume('*')) {
int num2 = F();
num1 *= num2;
}
return num1;
}
int E() {
int term1 = T();
while(1) {
bool cont = 0;
while(try_consume('+')) {
cont = 1;
int term2 = T();
term1 += term2;
}
while(try_consume('-')) {
cont = 1;
int term2 = T();
term1 -= term2;
}
if(!cont) break;
}
return term1;
}
bool Q() {
int expr1 = E();
consume('=');
int expr2 = E();
return expr1 == expr2 && idx == N;
}
int main() {
string T = "01+-*()=";
sort(T.begin(), T.end());
string RS; cin >> RS;
N = RS.size();
for(auto c: RS) if(isalpha(c)) alphas.push_back(c);
sort(alphas.begin(), alphas.end());
alphas.erase(unique(alphas.begin(), alphas.end()), alphas.end());
M = alphas.size();
if(M > T.size()) {
cout << 0 << endl;
return 0;
}
int ans = 0;
set<string> st;
do {
S = RS;
rep(i, N) {
if(isalpha(S[i])) S[i] = T[alphas.find(S[i])];
}
if(!st.count(S)) {
st.insert(S);
idx = curr = 0;
try { ans += Q(); } catch (exception e) {}
}
} while(next_permutation(T.begin(), T.end()));
cout << ans << endl;
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define pb push_back
typedef string::const_iterator State;
int ans;
string s;
ll exp(State &begin);
ll bin(State &begin){
ll ret=0;
while(isdigit(*begin)){
ret*=2;
ret+=*begin-'0';
begin++;
}
return ret;
}
ll number(State &begin){
if(*begin=='0'){
begin++;
if(isdigit(*begin))throw "number error1";
else return 0;
}
else if(*begin=='1'){
return bin(begin);
}else throw "number error2";
assert(1);
return -1;
}
ll factor(State &begin){
if( isdigit(*begin) )return number(begin);
else if(*begin=='-'){
begin++;
if(isdigit(*begin)||*begin=='('||*begin=='-') return -1*factor(begin);
else throw "factor error1";
}else if(*begin=='('){
begin++;
ll ret = exp(begin);
if(*begin!=')')throw "factor error2";
begin++;
return ret;
}
else throw "factor error3";
assert(1);
return -1;
}
ll term(State &begin){
ll ret = factor(begin);
if(*begin=='+'||*begin=='-'||*begin=='$'||*begin==')'){
return ret;
}
else if(*begin=='*'){
begin++;
return ret*term(begin);
}
else throw "term error";
assert(1);
return -1;
}
ll exp(State &begin){
ll ret = term(begin);
while(1){
if(*begin=='+'){
begin++;
ret+=term(begin);
}else if(*begin=='-'){
begin++;
ret-=term(begin);
}else if(*begin=='$'||*begin==')'){
return ret;
}else throw "exp error";
}
assert(1);
return -1;
}
bool isValid(string tmp){
int eqc=0;
rep(i,tmp.size())if(tmp[i]=='=')eqc++;
if(eqc!=1)return false;
string str[2]={};
bool f=false;
rep(i,tmp.size()){
if(tmp[i]=='=')f=true;
else if(f)str[1]+=tmp[i];
else str[0]+=tmp[i];
}
if(str[0].size()==0||str[1].size()==0)return false;
State b[2];
ll res[2];
try{
rep(i,2){
str[i] +='$';
b[i] = str[i].begin();
res[i] = exp(b[i]);
}
}catch(char const* e){ return false; }
if(res[0]==res[1] && *b[0]=='$'&&*b[1]=='$'){
return true;
}else return false;
}
void dfs(string tmp,vector<bool> used){
char alp='!';
int pos=-1;
rep(i,tmp.size()){
if(isalpha(tmp[i]))alp=tmp[i],pos=i;
}
if(pos==-1){ if(isValid(tmp))ans++; return; }
assert(alp!='!');
string symbols = "01+-*()=";
rep(i,symbols.size()){
if(used[i])continue;
used[i]=true;
string ntmp = tmp;
rep(j,ntmp.size()){
if(ntmp[j]==alp) ntmp[j] = symbols[i];
}
dfs(ntmp,used);
used[i]=false;
}
}
int main(){
cin>>s;
set<char> st;
vector<char> vs;
rep(i,s.size())st.insert(s[i]);
for(auto &e:st)vs.pb(e);
int count=0;
rep(i,vs.size())if(isalpha(vs[i]))count++;
if(count>8){
cout<<0<<endl;
return 0;
}
ans=0;
vector<bool> used(8,false);
dfs(s,used);
cout<<ans<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef pair<string,string> P;
int bnf();
set<P> used;
map<char,int> M;
string S;
int idx,valid;
char ch[8]={'0','1','+','-','*','(',')','='};
int ord[8];
bool check(string a){//???????????????????°????¨????????????????????????¢????
int par=0;
for(char s:a){
par += (s == '(') - (s == ')');
if(s == '=') return 0;
if(par < 0) return 0;
}
return par==0;
}
int getNum(){ //????????????????°????????????
int res = 0;
if(S[idx] == '0' && isdigit(S[idx+1])) valid = 0;
while(isdigit(S[idx]))res = res*2 + S[idx++]-'0';
return res;
}
int cal(){
char ch = S[idx];
int res = 0,sign = 1;
if(ch=='+'||ch=='*'||ch==')'){ valid = 0;return 0;}
while(S[idx] == '-') idx++, sign *= -1;
ch = S[idx];
if(isdigit(ch)){
res = sign*getNum();
if(S[idx] == '*'){idx++; return res * cal();}
return res;
}
else if(ch == '(') {
idx++;res = sign*bnf();idx++;
return res;
}
valid = 0;
return 0;
}
int bnf(){
int res = cal();
while(idx<(int)S.size()){
if(valid == 0) return -1;
char ch = S[idx];
if(ch == '('){valid = 0;}
else if(ch == '*'){idx++;res *= cal();}
else if(ch == '+'){idx++;res += cal();}
else if(ch == '-'){idx++;res -= cal();}
else if(ch != ')') valid = 0;
else break;
}
if(valid ==0) return -1;
return res;
}
string mkS(string a){
string res;
for(char s:a){
if(isalpha(s))res += ch[ ord[ M[s] ] ];
else res += s;
}
return res;
}
int calc(string A,string B){
if(A.size()==0 || B.size()==0) return 0;
if(used.count(P(A,B)))return 0;
used.insert(P(A,B));
valid = check(A) && check(B);
idx = 0;
S = A;
int ra = bnf();
idx = 0;
S = B;
int rb = bnf();
//if(valid)cout<<A<<"="<<B<<" "<<valid<<" "<<ra<<" "<<rb<<endl;
return ra == rb && valid;
}
int calc(string s){
s = mkS(s);
for(int i=0;i<(int)s.size();i++)
if(s[i]=='=') return calc(s.substr(0,i),s.substr(i+1,s.size()-i-1));
return 0;
}
int dfs(int num,string &s){
if(num == 8) return calc(s);
int res = 0;
for(int i=0;i<8;i++){
if(ord[i] != -1)continue;
ord[i] = num;
res +=dfs(num+1,s);
ord[i] = -1;
}
return res;
}
int main(){
string str;
cin>>str;
if(str.size()<3)cout<<0<<endl,exit(0);
map<char,int> cnt;
for(int i=0;i<(int)str.size();i++)if(isalpha(str[i]))cnt[str[i]]++;
if(cnt.size()>8)cout<<0<<endl,exit(0);
int c = 0;
for(pair<char,int> p:cnt)if(isalpha(p.first)) M[p.first] = c++;
memset(ord,-1,sizeof(ord));
cout<<dfs(0,str)<<endl;
return 0;
} |
#include <algorithm>
#include <iostream>
#include <vector>
#include <cctype>
using namespace std;
int expr(string &s, int &p);
int term(string &s, int &p);
int factor(string &s, int &p);
int number(string &s, int &p);
bool ng;
// Q ::= E=E
bool is_eq(string &s) {
if (count(s.begin(), s.end(), '=') != 1) return false;
int k = s.find('=');
string a = s.substr(0, k), b = s.substr(k + 1);
auto check = [](string &s) {
if (s.size() == 0) return false;
int br = 0;
for (char c: s) {
br += (c == '(') - (c == ')');
if (br < 0) return false;
}
return br == 0;
};
if (!check(a) || !check(b)) return false;
ng = false;
int p = 0, x = expr(a, p);
if (ng || p != a.size()) return false;
int q = 0, y = expr(b, q);
if (ng || q != b.size()) return false;
return x == y;
}
// E ::= T | E+T | E−T
int expr(string &s, int &p) {
int res = term(s, p);
while (p < s.size()) {
if (s[p] == '+') { res += term(s, ++p); continue; }
if (s[p] == '-') { res -= term(s, ++p); continue; }
break;
}
return res;
}
// T ::= F | T*F
int term(string &s, int &p) {
int res = factor(s, p);
while (p < s.size()) {
if (s[p] == '*') { res *= factor(s, ++p); continue; }
break;
}
return res;
}
// F ::= N | −F | (E)
int factor(string &s, int &p) {
int res;
if (s[p] == '-') {
res = -factor(s, ++p);
} else if (s[p] == '(') {
++p;
res = expr(s, p);
++p;
} else if (isdigit(s[p])) {
res = number(s, p);
} else {
return ng = true;
}
return res;
}
// N ::= 0 | 1B
// B ::= ϵ | 0B | 1B
int number(string &s, int &p) {
if (s[p] == '0') {
if (p + 1 < s.size() && isdigit(s[p + 1])) return ng = true;
return p++, 0;
}
int res = 0;
while (p < s.size() && isdigit(s[p])) res = res * 2 + s[p++] - '0';
return res;
}
int main() {
string s; cin >> s;
vector<char> cs;
for (auto c: s) if (isalpha(c)) cs.emplace_back(c);
sort(cs.begin(), cs.end());
cs.erase(unique(cs.begin(), cs.end()), cs.end());
if (cs.size() > 8) return !(cout << 0 << endl);
int cnt = 0;
string p = "=+-*()01";
sort(p.begin(), p.end());
do {
string t = s;
for (auto &c: t) if (isalpha(c)) {
int k = lower_bound(begin(cs), end(cs), c) - begin(cs);
c = p[k];
}
cnt += is_eq(t);
} while (next_permutation(p.begin(), p.end()));
for (int i = 0; i < p.size() - cs.size(); i++) cnt /= i + 1;
cout << cnt << endl;
return 0;
}
|
#include "bits/stdc++.h"
#include <sys/timeb.h>
#include <fstream>
using namespace std;
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define replrev(i,a,b) for(int i=(int)(b)-1;i>=(int)(a);i--)
#define reprev(i,n) replrev(i,0,n)
#define repi(itr,ds) for(auto itr=ds.begin();itr!=ds.end();itr++)
#define all(a) a.begin(),a.end()
#define mp make_pair
#define mt make_tuple
#define INF 2000000000
#define INFL 1000000000000000000LL
#define EPS (1e-8)
#define MOD 1000000007
#define PI 3.1415926536
#define RMAX 4294967295
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<P> vP;
typedef vector<vector<int> > vvi;
typedef vector<vector<bool> > vvb;
typedef vector<vector<ll> > vvll;
typedef vector<vector<char> > vvc;
typedef vector<vector<string> > vvs;
typedef vector<vector<double> > vvd;
typedef vector<vector<P> > vvP;
typedef priority_queue<int, vector<int>, greater<int> > pqli;
typedef priority_queue<ll, vector<ll>, greater<ll> > pqlll;
typedef priority_queue<P, vector<P>, greater<P> > pqlP;
//*
// ????????????????§?????§£?????¨
typedef string::const_iterator State;
class ParseError {};
//*/
struct Edge {
int from, to, cost;
bool operator<(Edge e) {
return cost < e.cost;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
bool isB(string &str, map<char, char> &m, State &state, State end) {
if (state == end)return true;
if (m[*state] == '0' || m[*state] == '1') {
state++;
return isB(str, m, state, end);
}
else {
return false;
}
}
bool isN(string &str, map<char, char> &m, State &state, State end) {
if (state == end)return false;
if (m[*state] == '0') {
state++;
if (state == end)return true;
else return false;
}
else if (m[*state] == '1') {
state++;
return isB(str, m, state, end);
}
else return false;
}
bool isE(string &str, map<char, char> &m, State &state, State end);
bool isF(string &str, map<char, char> &m, State &state, State end) {
if (state == end)return false;
if (m[*state] == '-') {
state++;
return isF(str, m, state, end);
}
else if (m[*state] == '(') {
state++;
if (state == end)return false;
end--;
if (isE(str, m, state, end)) {
state++;
return true;
}
else {
state++;
return false;
}
}
else {
return isN(str, m, state, end);
}
}
bool isT(string &str, map<char, char> &m, State &state, State end) {
if (state == end)return false;
State tmp = state;
int paren = 0;
if (m[*state] == '(')paren = 1;
while (++state != end) {
if (m[*state] == '*') {
if (paren > 0)continue;
if (!isF(str, m, tmp, state)) {
return false;
}
tmp = state + 1;
}
else if (m[*state] == '(') {
paren++;
}
else if (m[*state] == ')') {
paren--;
}
}
if (!isF(str, m, tmp, state)) {
return false;
}
return true;
}
bool isE(string &str, map<char, char> &m, State &state, State end) {
if (state == end)return false;
State tmp = state;
int paren = 0;
if (m[*state] == '(')paren++;
bool prod = false;
while (++state != end) {
if (m[*state] == '+' || m[*state] == '-') {
if (paren > 0)continue;
if (prod) {
prod = false;
continue;
}
prod = false;
if (!isT(str, m, tmp, state)) {
return false;
}
tmp = state + 1;
}
else if (m[*state] == '(') {
prod = false;
paren++;
}
else if (m[*state] == ')') {
prod = false;
paren--;
}
else if (m[*state] == '*') {
prod = true;
}
else {
prod = false;
}
}
if (!isT(str, m, tmp, state)) {
return false;
}
return true;
}
bool isQ(string str, map<char, char> &m) {
int index = -1;
rep(i, str.size()) {
if (m[str[i]] == '=') {
if (index != -1)return false;
index = i;
}
}
if (index == -1)return false;
// ??????????????§??????
int num = 0;
rep(i, index) {
if (m[str[i]] == '(')num++;
else if (m[str[i]] == ')')num--;
if (num < 0)return false;
}
if (num != 0)return false;
repl(i, index + 1, str.size()) {
if (m[str[i]] == '(')num++;
else if (m[str[i]] == ')')num--;
if (num < 0)return false;
}
if (num != 0)return false;
// +?????§??????
rep(i, str.size()) {
if (m[str[i]] == '+') {
if (i == 0 || !(m[str[i - 1]] == '0' || m[str[i - 1]] == '1' || m[str[i - 1]] == ')'))return false;
}
}
// --,+-???????????????
string tmp = "";
vc charr(str.size());
rep(i, str.size()) {
charr[i] = str[i];
}
rep(i, charr.size() - 1) {
if (m[charr[i]] == '-'&&m[charr[i + 1]] == '-') {
charr[i + 1] = '+';
}
else if (m[charr[i]] == '+'&&m[charr[i + 1]] == '-') {
charr[i + 1] = '-';
}
else {
if (tmp.size() == 0 && charr[i] == '+') {
continue;
}
else if (tmp.size() > 0 && (m[tmp[tmp.size() - 1]] == '=' || m[tmp[tmp.size() - 1]] == '(' || m[tmp[tmp.size() - 1]] == '*') && charr[i] == '+') {
continue;
}
tmp += charr[i];
}
}
tmp += charr[charr.size() - 1];
//cout << tmp << endl;
rep(i, tmp.size()) {
if (m[tmp[i]] == '=') {
index = i;
break;
}
}
State state = tmp.begin();
if (!isE(tmp, m, state, state + index))return false;
state++;
if (!isE(tmp, m, state, tmp.end()))return false;
return true;
}
int N(string &str, map<char, char> &m, State &state, State end) {
int val = 0;
while (state != end) {
val <<= 1;
if (m[*state] == '1') {
val += 1;
}
state++;
}
return val;
}
int E(string &str, map<char, char> &m, State &state, State end);
int F(string &str, map<char, char> &m, State &state, State end) {
if (state == end)return false;
if (m[*state] == '-') {
state++;
return -F(str, m, state, end);
}
else if (m[*state] == '(') {
state++;
if (state == end)return false;
end--;
int val = E(str, m, state, end);
state++;
return val;
}
else {
return N(str, m, state, end);
}
}
int T(string &str, map<char, char> &m, State &state, State end) {
if (state == end)return false;
State tmp = state;
int val = 1;
int paren = 0;
if (m[*state] == '(')paren = 1;
while (++state != end) {
if (m[*state] == '*') {
if (paren > 0)continue;
val *= F(str, m, tmp, state);
tmp = state + 1;
}
else if (m[*state] == '(') {
paren++;
}
else if (m[*state] == ')') {
paren--;
}
}
val *= F(str, m, tmp, state);
return val;
}
int E(string &str, map<char, char> &m, State &state, State end) {
State tmp = state;
int val = 0;
bool plus = true;
int paren = 0;
if (m[*state] == '(')paren = 1;
bool prod = false;
while (++state != end) {
if (m[*state] == '+') {
if (paren > 0)continue;
if (prod) {
prod = false;
continue;
}
if (plus) {
val += T(str, m, tmp, state);
}
else {
val -= T(str, m, tmp, state);
}
prod = false;
plus = true;
tmp = state + 1;
//state++;
}
else if (m[*state] == '-') {
if (paren > 0)continue;
if (prod) {
prod = false;
continue;
}
prod = false;
if (plus) {
val += T(str, m, tmp, state);
}
else {
val -= T(str, m, tmp, state);
}
plus = false;
tmp = state + 1;
//state++;
}
else if (m[*state] == '(') {
prod = false;
paren++;
}
else if (m[*state] == ')') {
prod = false;
paren--;
}
else if (m[*state] == '*') {
prod = true;
}
else {
prod = false;
}
}
if (plus) {
val += T(str, m, tmp, state);
}
else {
val -= T(str, m, tmp, state);
}
return val;
}
bool check(string str, map<char, char> &m) {
// --,+-???????????????
string tmp = "";
vc charr(str.size());
rep(i, str.size()) {
charr[i] = str[i];
}
rep(i, charr.size() - 1) {
if (m[charr[i]] == '-'&&m[charr[i + 1]] == '-') {
charr[i + 1] = '+';
}
else if (m[charr[i]] == '+'&&m[charr[i + 1]] == '-') {
charr[i + 1] = '-';
}
else {
if (tmp.size() == 0 && charr[i] == '+') {
continue;
}
else if (tmp.size() > 0 && m[tmp[tmp.size() - 1]] == '=' && charr[i] == '+') {
continue;
}
tmp += charr[i];
}
}
tmp += charr[charr.size() - 1];
int index = -1;
rep(i, tmp.size()) {
if (m[tmp[i]] == '=') {
index = i;
break;
}
}
int lhs = 0, rhs = 0;
State state = tmp.begin();
lhs = E(tmp, m, state, state + index);
state++;
rhs = E(tmp, m, state, tmp.end());
//cout << lhs << " " << rhs << endl;
return lhs == rhs;
}
int main(void) {
/*
ofstream ofs("output.txt");
cout.rdbuf(ofs.rdbuf());
*/
string str;
cin >> str;
vc ch;
set<char> st;
for (char c : str) {
if (c == '0' || c == '1' || c == '+' || c == '-' || c == '*' || c == '(' || c == ')' || c == '=')continue;
if (st.find(c) == st.end()) {
st.insert(c);
ch.push_back(c);
}
}
if (ch.size() > 8) {
cout << 0 << endl;
return 0;
}
char simbol[] = { '0','1','+','-','*','(',')','=' };
vi perm(8);
rep(i, 8)perm[i] = i;
map<char, char>m;
m['0'] = '0';
m['1'] = '1';
m['+'] = '+';
m['-'] = '-';
m['*'] = '*';
m['('] = '(';
m[')'] = ')';
m['='] = '=';
/*
string d = "(0)";
cout << "xo"[isE(d, m, d.begin(), d.end())] << endl;
//cout << "xo"[isQ("1+11*1-11010=(10110)-10", m)] << endl;
cout << "xo"[isQ("(--0)=0", m)] << endl;
cout << "xo"[check("(--0)=0", m)] << endl;
return 0;
//*/
int count = 0;
int ans = 0;
do {
rep(i, ch.size()) {
m[ch[i]] = simbol[perm[i]];
}
if (isQ(str, m)) {
/*
for (char c : str) {
cout << m[c];
}
cout << " : " << "xo"[isQ(str, m) ? 1 : 0] << " ";
if (isQ(str, m)) {
cout << "xo"[check(str, m) ? 1 : 0] << " ";
}
cout << count << endl;
//*/
if (check(str, m)) {
//cout << "=======================" << endl;
ans++;
}
}
/*
if (count % 720 == 0) {
for (char c : str) {
cout << m[c];
}
cout << " : " << "xo"[isQ(str, m) ? 1 : 0] << " ";
if (isQ(str, m)) {
cout << "xo"[check(str, m) ? 1 : 0] << " ";
}
cout << count << endl;
}
count++;
//*/
} while (next_permutation(perm.begin(), perm.end()));
repl(i, 1, 9 - ch.size()) {
ans /= i;
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
#include <stdexcept>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
string S;
int idx;
int N, M;
string alphas;
int curr;
void consume(char c) {
if(idx >= N) throw exception();
if(S[idx] != c) throw exception();
idx ++;
}
bool try_consume(char c) {
if(idx >= N) return false;
if(S[idx] != c) return false;
idx ++;
return true;
}
int E();
int convert(string const& b) {
int n = b.size();
int ret = 0;
for(int i=0; i<n; i++) {
ret *= 2;
assert(isdigit(b[i]));
ret += b[i] - '0';
}
return ret;
}
string B() {
string ret;
while(1) {
if(S[idx] == '0') ret += '0';
else if(S[idx] == '1') ret += '1';
else break;
idx++;
}
return ret;
}
int Nu() {
if(try_consume('0')) return 0;
consume('1');
return convert("1" + B());
}
int F() {
if(try_consume('-')) {
return -F();
}
else if(try_consume('(')) {
int r = E();
consume(')');
return r;
}
else {
return Nu();
}
}
int T() {
int num1 = F();
while(try_consume('*')) {
int num2 = F();
num1 *= num2;
}
return num1;
}
int E() {
int term1 = T();
while(1) {
bool cont = 0;
while(try_consume('+')) {
cont = 1;
int term2 = T();
term1 += term2;
}
while(try_consume('-')) {
cont = 1;
int term2 = T();
term1 -= term2;
}
if(!cont) break;
}
return term1;
}
bool Q() {
int expr1 = E();
consume('=');
int expr2 = E();
return expr1 == expr2 && idx == N;
}
int main() {
string T = "01+-*()=";
sort(T.begin(), T.end());
string RS; cin >> RS;
N = RS.size();
for(auto c: RS) if(isalpha(c)) alphas.push_back(c);
sort(alphas.begin(), alphas.end());
alphas.erase(unique(alphas.begin(), alphas.end()), alphas.end());
M = alphas.size();
if(M > T.size()) {
cout << 0 << endl;
return 0;
}
int ans = 0;
set<string> st;
do {
S = RS;
rep(i, N) {
if(isalpha(S[i])) S[i] = T[alphas.find(S[i])];
}
if(!st.count(S)) {
st.insert(S);
idx = curr = 0;
try { ans += Q(); } catch (...) {}
}
} while(next_permutation(T.begin(), T.end()));
cout << ans << endl;
return 0;
} |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <string>
#include <cctype>
#include <set>
#define ALL(a) (a).begin(), (a).end()
#define FOR(i, a ,b) for(int i = int(a); i < int(b); ++i)
#define REP(i, a) FOR(i, 0, a)
#define RFOR(i, a, b) for(int i = int(b)-1; i >= int(a); --i)
#define RREP(i,a) RFOR(i, 0, a)
#define IN(a, x , b) (a <= x && x <= b)
template<class T> inline void CHMIN(T& a, T& b){if(a<b)a=b;}
template<class T> inline void CHMAX(T& a, T& b){if(a>b)a=b;}
using ll = long long;
template<class T> using V = std::vector<T>;
using namespace std;
string ops = "01+-*()=";
int n;
bool ok;
using State = string::const_iterator;
ll E(State& it, const State& end);
ll T(State& it, const State& end);
ll F(State& it, const State& end);
ll N(State& it, const State& end);
ll E(State& it, const State& end) {
if(it >= end) {
ok = false;
return 0;
}
ll res = T(it, end);
while(it < end) {
if(*it == '+') {
++it;
res += T(it, end);
}
else if(*it == '-') {
++it;
res -= T(it, end);
}
else {
break;
}
}
return res;
}
ll T(State& it, const State& end) {
if(it >= end) {
ok = false;
return 0;
}
ll res = F(it, end);
while(it < end) {
if(*it == '*') {
++it;
res *= F(it, end);
}
else {
break;
}
}
return res;
}
ll F(State& it, const State& end) {
if(it >= end) {
ok = false;
return 0;
}
if(*it == '0' || *it == '1') {
return N(it, end);
}
else if(*it == '-') {
++it;
return -F(it, end);
}
else if(*it == '(') {
++it;
ll res = E(it, end);
if(it >= end || *it != ')') {
ok = false;
return 0;
}
++it;
return res;
}
else {
ok = false;
return 0;
}
}
ll N(State& it, const State& end) {
if(it >= end) {
ok = false;
return 0;
}
if(*it == '0' && it + 1 < end && (*(it + 1) == '0' || *(it + 1) == '1')) {
ok = false;
return 0;
}
ll res = 0;
while(it < end) {
if(*it == '0') {
++it;
res = res * 2;
}
else if(*it == '1') {
++it;
res = res * 2 + 1;
}
else {
break;
}
}
return res;
}
bool isValid(const string& s) {
if(s[0] == '=' || s[n-1] == '=') return false;
int eqpos = -1;
REP(i, n) {
if(s[i] == '=') {
if(eqpos == -1) {
eqpos = i;
}
else {
return false;
}
}
}
if(eqpos == -1) return false;
string left = s.substr(0, eqpos);
string right = s.substr(eqpos + 1);
ok = true;
ll leftval;
{
auto start = s.cbegin();
auto end = s.cbegin() + eqpos;
leftval = E(start, end);
if(!ok || start != end) return false;
}
ll rightval;
{
auto start = s.cbegin() + eqpos + 1;
auto end = s.cend();
rightval = E(start, end);
if(!ok || start != end) return false;
}
return leftval == rightval;
}
int main(){
string s;
cin >> s;
n = s.size();
V<int> mapto(256, -1);
int sz = 0;
{
map<char, char> mp;
REP(i, n) {
if(isalpha(s[i])) mp[s[i]];
}
if(mp.size() > ops.size()) {
cout << 0 << '\n';
return 0;
}
for(auto& p : mp) {
p.second = sz++;
mapto[p.first] = p.second;
}
}
sort(ALL(ops));
V<int> o(ops.size(), 0);
REP(i, sz) o[i] = 1;
reverse(ALL(o));
int ans = 0;
do{
string ops2;
REP(i, o.size()) if(o[i]) ops2 += ops[i];
do{
string s2(s);
REP(i, n) {
if(isalpha(s2[i])) s2[i] = ops2[mapto[s2[i]]];
}
if(isValid(s2)) {
++ans;
//cout << s2 << endl;
}
}while(next_permutation(ALL(ops2)));
}while(next_permutation(ALL(o)));
cout << ans << '\n';
}
|
#include <iostream>
#include <string>
#include <cstdlib>
#include <map>
#include <cctype>
#include <vector>
using namespace std;
typedef long long LL;
const string charset = "01+-*()=";
string input;
int sz;
int ans;
map<char,int> mp;
vector<char> tbl;
const char *p;
LL expr();
LL term();
LL factor();
LL expr(){
LL x = term();
while(1){
if(*p == '+'){
++p;
LL y = term();
x += y;
}
else if(*p == '-'){
++p;
LL y = term();
x -= y;
}
else{ break; }
}
return x;
}
LL term(){
LL x = factor();
while(*p == '*'){
++p;
LL y = factor();
x *= y;
}
return x;
}
LL factor(){
if(*p == '-'){
++p;
LL x = factor();
return -x;
}
if(*p == '('){
++p;
LL x = expr();
if(*p != ')'){ throw 1; }
++p;
return x;
}
if(*p == '0'){
++p;
return 0;
}
if(*p == '1'){
char *endp;
LL x = strtoll(p, &endp, 2);
p = endp;
return x;
}
throw 2;
}
void check() try{
string e;
for(char c : input){
if(isalpha(c)){
e += tbl[mp[c]];
}
else{
e += c;
}
}
p = e.c_str();
LL lt = expr();
if(*p == '='){
++p;
LL rt = expr();
if(!*p && lt == rt){
++ans;
}
}
}
catch(...){}
void dfs(int i, int u){
if(i == sz){
check();
}
else{
for(int j = 0; j < 8; ++j){
if(!(u >> j & 1)){
tbl[i] = charset[j];
dfs(i + 1, u | 1 << j);
}
}
}
}
int main(){
cin >> input;
for(char c : input){
if(isalpha(c)){
mp.emplace(c, mp.size());
}
}
sz = mp.size();
if(sz <= 8){
tbl.assign(sz, 0);
dfs(0, 0);
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
string S;
int idx;
int N, M;
string alphas;
int curr;
bool try_consume(char c) {
if(S[idx] != c) return false;
idx ++;
return true;
}
int E();
int convert(string const& b) {
int n = b.size();
int ret = 0;
for(int i=0; i<n; i++) {
ret *= 2;
assert(isdigit(b[i]));
ret += b[i] - '0';
}
return ret;
}
string B() {
string ret;
while(1) {
if(S[idx] == '0') ret += '0';
else if(S[idx] == '1') ret += '1';
else break;
idx++;
}
return ret;
}
int Nu() {
if(try_consume('0')) return 0;
if(!try_consume('1')) return -inf;
return convert("1" + B());
}
int F() {
if(try_consume('-')) {
int f = F();
if(f == -inf) return -inf;
return -f;
}
else if(try_consume('(')) {
int r = E();
if(!try_consume(')')) return -inf;
return r;
}
else {
return Nu();
}
}
int T() {
int num1 = F();
if(num1 == -inf) return -inf;
while(try_consume('*')) {
int num2 = F();
if(num2 == -inf) return -inf;
num1 *= num2;
}
return num1;
}
int E() {
int term1 = T();
if(term1 == -inf) return -inf;
while(1) {
bool cont = 0;
while(try_consume('+')) {
cont = 1;
int term2 = T();
if(term2 == -inf) return -inf;
term1 += term2;
}
while(try_consume('-')) {
cont = 1;
int term2 = T();
if(term2 == -inf) return -inf;
term1 -= term2;
}
if(!cont) break;
}
return term1;
}
bool Q() {
int expr1 = E();
if(expr1 == -inf) return false;
if(!try_consume('=')) return false;
int expr2 = E();
if(expr2 == -inf) return false;
return expr1 == expr2 && idx == N;
}
int main() {
string T = "01+-*()=";
sort(T.begin(), T.end());
string RS; cin >> RS;
N = RS.size();
for(auto c: RS) if(isalpha(c)) alphas.push_back(c);
sort(alphas.begin(), alphas.end());
alphas.erase(unique(alphas.begin(), alphas.end()), alphas.end());
M = alphas.size();
if(M > T.size()) {
cout << 0 << endl;
return 0;
}
int ans = 0;
set<string> st;
do {
S = RS;
rep(i, N) {
if(isalpha(S[i])) S[i] = T[alphas.find(S[i])];
}
if(!st.count(S)) {
st.insert(S);
idx = curr = 0;
ans += Q();
}
} while(next_permutation(T.begin(), T.end()));
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define ll long long
using namespace std;
string str;
bool Q(size_t &i);
ll E(size_t &i);
ll T(size_t &i);
ll F(size_t &i);
ll N(size_t &i);
bool Q(size_t &i){
ll lhs = 1, rhs = 0;
try{
lhs = E(i);
if(i == str.size() || str[i] != '=')return false;
rhs = E(++i);
} catch(int){
return false;
}
// cerr << lhs << " " << rhs << endl;
if(i < str.size())return false;
if(lhs == rhs)return true;
else return false;
}
ll E(size_t &i){
auto lhs = T(i);
// cerr << lhs << ";";
while(i < str.size()){
auto ope = str[i];
if(ope != '+' && ope != '-')return lhs;
auto rhs = T(++i);
if(ope == '+')lhs = lhs + rhs;
else if(ope == '-')lhs = lhs - rhs;
else return lhs;
}
return lhs;
}
ll T(size_t &i){
ll lhs = F(i);
while(i < str.size() && str[i] == '*'){
auto rhs = F(++i);
lhs = lhs * rhs;
}
return lhs;
}
ll F(size_t &i){
if(i >= str.size())throw -1;
if(str[i] == '('){
ll ret = E(++i);
if(i >= str.size() || str[i] != ')')throw -1;
i++;
return ret;
}
if(str[i] == '-'){
auto ret = F(++i);
return -ret;
}
return N(i);
}
ll N(size_t &i){
if(str[i] == '0'){i++; return 0;}
if(str[i] != '1')throw -1;
ll ret = 1;
i++;
for(;i < str.size() && isdigit(str[i]);i++){
ret <<= 1;
if(str[i] == '1')ret += 1;
}
return ret;
}
bool next_combination(const vector<int>::iterator begin, const vector<int>::iterator end, const int r){
if(r == 0)return false;
auto target = upper_bound(begin, begin+r, *(end-1));
if(target != begin)--target;
if(target == begin && *target >= *(end-1)){
rotate(begin, begin+r, end);
return false;
}
// cerr << "hi";
auto next = upper_bound(begin+r, end, *target);
swap(*target, *next);
++target; ++next;
vector<int> arr;
for(auto itr = next; itr != end; ++itr)arr.push_back(*itr);
for(auto itr = target; itr != begin+r; ++itr)arr.push_back(*itr);
size_t idx = 0;
for(auto itr = target; itr != end && idx < arr.size(); ++itr){
if(itr == begin+r && next != end)itr = next;
swap(arr[idx], *itr);
idx++;
}
return true;
}
signed main(){
string raw;
cin >> raw;
map<char, int> m;
int cnt = 0;
for(auto e : raw){
if(isalpha(e) && m.find(e) == m.end()){
m[e] = cnt++;
}
}
// cerr << cnt << endl;
if(cnt > 8){
cout << 0 << endl;
return 0;
}
vector<char> c = {'0', '1', '+', '-', '*', '(', ')', '='};
vector<int> idx={0,1,2,3,4,5,6,7};
int ans = 0;
do{
do{
size_t i = 0;
for(auto &e : raw){
if(m.find(e) != m.end()){
str.push_back(c[idx[m[e]]]);
}
else{
str.push_back(e);
}
}
// cerr << str << endl;
if(Q(i)){
ans++;
}
str.resize(0);
}while(next_permutation(idx.begin(), idx.begin()+cnt));
}while(cnt != 8 && next_combination(ALL(idx),cnt));
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int len,p;
string S;
bool flag;
int compute();
int getNum(){
if(p>=len){
flag=true;
return 0;
}
if(S[p]=='-'){
p++;
return -getNum();
}else if(S[p]=='0'){
p++;
return 0;
}else if(S[p]=='1'){
int res=0;
while(p<len && (S[p]=='0'||S[p]=='1') ){
res*=2;
res+=(S[p]-'0');
p++;
}
return res;
}else if(S[p]=='('){
p++;
int res=compute();
if(S[p-1]!=')')flag=true;
return res;
}else{
flag=true;
return 0;
}
}
int compute(){
if(p>=len){
flag=true;
return 0;
}
stack<int> st;
st.push( getNum() );
while(p<len){
char ch=S[p];p++;
if(ch==')')break;
int num=getNum();
if(ch=='+'){
st.push(num);
}else if(ch=='-'){
st.push(-num);
}else if(ch=='*'){
int x=st.top();
st.pop();
st.push(x*num);
}else{
flag=true;
break;
}
}
int res=0;
while(st.size()>0){
res+=st.top();
st.pop();
}
return res;
}
int check(string str){
string le,ri;
int cnt=0,index;
for(int i=0;i<(int)str.size();i++)
if(str[i]=='=')cnt++, index=i;
if(cnt!=1)return 0;
if(index==0 || index+1==(int)str.size())return 0;
flag=false;
S=str.substr(0,index);
p=0;
len=S.size();
le=S;
int lv=compute();
int ca=0,cb=0;
for(int i=0;i<S.size();i++)
if(S[i]=='(')ca++;
else if(S[i]==')')cb++;
if( ca!=cb || flag || p<len)return 0;
flag=false;
S=str.substr(index+1);
ri=S;
p=0;
len=S.size();
int rv=compute();
ca=0,cb=0;
for(int i=0;i<S.size();i++)
if(S[i]=='(')ca++;
else if(S[i]==')')cb++;
if( ca!=cb || flag || p<len)return 0;
if(lv==rv){
// cout<<le<<' '<<ri<<endl;
return 1;
}else return 0;
}
int solve(string str){
string tmp="01+-*()=";
sort(tmp.begin(),tmp.end());
map<string,bool> used;
int res=0;
do{
map<char,char> mp;
string s=str;
for(int i=0;i<(int)s.size();i++){
if( ('A'<=s[i]&&s[i]<='Z') || ('a'<=s[i]&&s[i]<='z') ){
if(mp.count( s[i] )>0){
s[i]=mp[ s[i] ];
}else{
int id=mp.size();
mp[ s[i] ]=tmp[id];
s[i]=tmp[id];
}
}
}
if(!used[s]){
used[s]=true;
res+=check(s);
}
}while(next_permutation(tmp.begin(),tmp.end()));
return res;
}
int main(){
string str;
cin>>str;
cout<<solve(str)<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < n; i++)
#define int long long
int n;
int m;
string a;
vector<char> ch={'0','1','+','-','*','=','(',')'};
set<char> stch={'0','1','+','-','*','=','(',')'};
bool subcheck(int l,int r){
if(l>r)return false;
if(l==r){
if(a[l]=='0'){
return true;
}
if(a[l]=='1'){
return true;
}
return false;
}
int dep=0;
for(int i=l;i<=r;i++){
if(a[i]=='('){
dep++;
}else if(a[i]==')'){
dep--;
}
if(dep<0)return false;
}
if(dep!=0)return false;
if(a[l]=='0'){
if(a[l+1]=='('){
return false;
}
if(a[l+1]==')'){
return false;
}
if(a[l+1]=='1'){
return false;
}
if(a[l+1]=='0'){
return false;
}
return subcheck(l+2,r);
}else if(a[l]=='1'){
int x =-1;
for(int i=l+1;i<=r;i++){
if(!isdigit(a[i])){
x = i;
break;
}
}
if(x==-1)return true;
if(a[x]=='('){
return false;
}
if(a[x]==')'){
return false;
}
return subcheck(x+1,r);
}else if(a[l]=='-'){
return subcheck(l+1,r);
}else if(a[l]=='('){
for(int i=l;i<=r;i++){
if(a[i]=='('){
dep++;
}else if(a[i]==')'){
dep--;
}
if(dep==0){
if(i==r){
return subcheck(l+1,r-1);
}else{
if(a[i+1]=='+'||a[i+1]=='-'||a[i+1]=='*'){
return subcheck(l+1,i-1)&&subcheck(i+2,r);
}else{
return false;
}
}
}
}
}else{
return false;
}
}
bool check(){
int cc = 0;
int pl = 0;
rep(i,a.size()){
if(a[i]=='='){
cc++;
pl = i;
}
}
if(cc!=1)return false;
return (subcheck(0,pl-1)&&subcheck(pl+1,n-1));
}
int calc(int l,int r);
int calc2(int l,int r);
int calc3(int l,int r){
int cnt =0;
int x =-1;
for(int i=l;i<=r;i++){
if(a[i]=='-'){
cnt++;
}else{
x = i;
break;
}
}
if(isdigit(a[x])){
int tmp = 0;
for(int i=x;i<=r;i++){
tmp *= 2;
tmp += a[i]-'0';
}
// cerr << cnt << endl;
// cerr <<l << " "<< x << " " << r << endl;
// cerr << a.substr(l,2) << " " <<tmp << endl;
if(cnt%2==0){
return tmp;
}else{
return -tmp;
}
}else{
if(cnt%2==0){
return calc(x+1,r-1);
}else{
return -calc(x+1,r-1);
}
}
}
int calc2(int l,int r){
int dep =0;
int tmp = 1;
int prel =l;
for(int i=l;i<=r;i++){
if(a[i]=='('){
dep++;
}else if(a[i]==')'){
dep--;
}
if(dep==0&&a[i]=='*'){
tmp *= calc3(prel,i-1);
prel=i+1;
}
}
tmp *= calc3(prel,r);
return tmp;
}
int calc(int l,int r){
if(l==r){
if(a[l]=='0'){
return 0;
}
if(a[l]=='1'){
return 1;
}
}
int dep=0;
int cnt=0;
int prel= l;
bool minusflag =0;
int tmp =0;
for(int i=l;i<=r;i++){
if(dep==0){
if(a[i]=='('){
cnt++;
}
if(isdigit(a[i])){
cnt++;
}
if(a[i]=='-'){
if(cnt != 0){
if(minusflag){
tmp -= calc2(prel,i-1);
}else{
tmp += calc2(prel,i-1);
}
cnt = 0;
prel = i+1;
minusflag = true;
}
}
if(a[i]=='+'){
if(minusflag){
tmp -= calc2(prel,i-1);
}else{
tmp += calc2(prel,i-1);
}
cnt = 0;
prel = i+1;
minusflag =false;
}
if(a[i]=='*'){
cnt = 0;
}
}
if(a[i]=='('){
dep++;
}else if(a[i]==')'){
dep--;
}
}
if(minusflag){
tmp -= calc2(prel,r);
}else{
tmp += calc2(prel,r);
}
return tmp;
}
bool eqcheck(){
int cc = 0;
int pl = 0;
rep(i,a.size()){
if(a[i]=='='){
cc++;
pl = i;
}
}
if(cc!=1)return false;
//cerr << calc(0,pl-1) << " " << calc(pl+1,n-1) << endl;
return (calc(0,pl-1)==calc(pl+1,n-1));
}
signed main(){
string s;
cin >> s;
map<char,int>mp;
for(int i=0;i<s.size();i++){
if(stch.count(s[i])==1)continue;
mp[s[i]]++;
}
if(mp.size()>8){
cout << 0 << endl;
return 0;
}
vector<char> ori;
for(auto x:mp){
ori.push_back(x.first);
}
n = s.size();
m = mp.size();
vector<int>v(8);
rep(i,8)v[i] =i;
int ans =0;
a.resize(n);
set<string> st;
do{
map<char,char>trans;
for(int i=0;i<ori.size();i++){
trans[ori[i]] = ch[v[i]];
}
for(int i=0;i<n;i++){
if(stch.count(s[i])==1){
a[i] = s[i];
}else{
a[i] = trans[s[i]];
}
}
if(st.count(a)==1){
continue;
}
st.insert(a);
if(check()){
//cerr << a << endl;
if(eqcheck()){
//cerr << a << endl;
ans++;
}
}
}while(next_permutation(v.begin(),v.end()));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Parser {
using itr = string::const_iterator;
itr now;
int ans;
// E ::= {T{+|-}}+T T|E+T|E−T
// T ::= {F*}+F F|T*F
// F ::= N|{-}+F|(E)
// N ::= 0|1B
// B ::= {0|1}* ϵ|0B|1B
Parser(const string &s) {
now = s.begin();
ans = E(now);
if(*now != '\0') {
throw "INVALID";
}
}
int E(itr &now) {
// cerr << "E" << endl;
// E ::= {T{+|-}}+T T|E+T|E−T
int ret = T(now);
while(*now != '\0') {
if(*now == '+') {
next(now, '+');
ret += T(now);
} else if(*now == '-') {
next(now, '-');
ret -= T(now);
} else {
return ret;
}
}
return ret;
}
int T(itr &now) {
// cerr << "T" << endl;
// T ::= {F*}+F F|T*F
int ret = F(now);
while(*now != '\0') {
if(*now == '*') {
next(now, '*');
ret *= T(now);
} else {
return ret;
}
}
return ret;
}
int F(itr &now) {
// cerr << "F" << endl;
// F ::= N|{-}+F|(E)
if(*now == '-') {
next(now, '-');
return -F(now);
} else if(*now == '(') {
next(now, '(');
int ret = E(now);
next(now, ')');
return ret;
} else {
return N(now);
}
}
int N(itr &now) {
// cerr << "N" << endl;
// N ::= 0|1B
if(*now == '0') {
next(now, '0');
return 0;
} else if(*now == '1') {
return B(now);
} else {
throw "INVALID";
}
}
int B(itr &now) {
// cerr << "B" << endl;
// B ::= {0|1}* ϵ|0B|1B
int ret = 0;
while(*now != '\0') {
if(*now == '0' or *now == '1') {
ret <<= 1;
ret += (*now) - '0';
next(now, {'0', '1'});
} else {
return ret;
}
}
return ret;
}
void next(itr &now, const char expected) {
vector<char> req = {expected};
next(now, req);
}
void next(itr &now, const vector<char> &expected) {
for(char c: expected){
if(*now == c){
now++;
return;
}
}
throw "INVALID";
// デバッグ用
fprintf(stderr, "Expected: ");
for(char c: expected) fprintf(stderr, "%c", c);
fprintf(stderr, "\nGot: %c\n", *now);
fprintf(stderr, "Rest: ");
while(*now) fprintf(stderr, "%c", *now++);
}
};
int main() {
vector<char> ex = {'0', '1', '+', '-', '*', '(', ')', '='};
string s; cin >> s;
map<char, char> mp;
for(char c : s) {
bool flg = true;
for(char cc : ex) {
if(c == cc) flg = false;
}
if(flg) mp[c] = '?';
}
if(mp.size() > 8) {
cout << 0 << '\n';
return 0;
}
int ans = 0;
sort(ex.begin(), ex.end());
// reverse(ex.begin(), ex.end());
do {
int idx = 0;
for(auto &e : mp) {
e.second = ex[idx];
++idx;
}
string str[2];
int nxt = 0;
bool valid = true;
for(char c : s) {
if(nxt == 2) {
valid = false;
break;
}
if(mp.count(c)) {
if(mp[c] == '=') {
++nxt;
continue;
}
str[nxt].push_back(mp[c]);
} else {
if(c == '=') {
++nxt;
continue;
}
str[nxt].push_back(c);
}
}
if(nxt == 1 and valid) {
if(str[0].size() == 0) continue;
if(str[1].size() == 0) continue;
try {
// cerr << str[0] << endl;
// cerr << str[1] << endl;
Parser parse0(str[0]);
Parser parse1(str[1]);
// cerr << parse0.ans << endl;
// cerr << parse1.ans << endl;
if(parse0.ans == parse1.ans) {
++ans;
}
}
catch(...) {
continue;
}
}
} while(next_permutation(ex.begin(), ex.end()));
int div = 1;
for(int i = 1; i <= 8 - mp.size(); ++i) {
div *= i;
}
cout << ans / div << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
bool err;
string e;
ll N(int l, int r);
ll F(int l, int r);
ll T(int l, int r);
ll E(int l, int r);
ll N(int l, int r){
if(l>r){
err = true;
return 0;
}
ll ret = 0;
for(int i=l; i<=r; ++i){
if(e[i]=='0' || e[i]=='1') ret = ret*2 + e[i]-'0';
else{
err = true;
return 0;
}
}
if(e[l]=='0'){
if(l!=r) err = true;
}
return ret;
}
ll F(int l, int r){
if(l>r){
err = true;
return 0;
}
if(e[l]=='('){
if(e[r]!=')') err = true;
return E(l+1,r-1);
}
else if(e[l]=='-'){
return -F(l+1,r);
}
else return N(l,r);
}
ll T(int l, int r){
if(l>r){
err = true;
return 0;
}
int b = 0;
int a_pos = -1;
for(int i=r; i>=l; --i){
if(e[i]==')') ++b;
else if(e[i]=='(') --b;
if(e[i]=='*'){
if(b==0){
a_pos = i;
break;
}
}
}
if(a_pos == -1) return F(l,r);
else return T(l,a_pos-1)*F(a_pos+1,r);
}
ll E(int l, int r){
if(l>r){
err = true;
return 0;
}
char op = '?';
int o_pos = -1;
int b = 0;
for(int i=r; i>=l; --i){
if(e[i]==')') ++b;
else if(e[i]=='(') --b;
if(e[i]=='+' && b==0){
o_pos = i;
op = '+';
break;
}
if(e[i]=='-' && b==0){
o_pos = i;
while(l<=o_pos && e[o_pos]=='-') --o_pos;
if(o_pos<l){
op = '?';
break;
}
else{
if(e[o_pos] == '+'){
op = '+';
break;
}
else if(e[o_pos] == '*') continue;
else{
++o_pos;
op = '-';
break;
}
}
}
}
if(op=='?') return T(l,r);
else if(op=='+') return E(l,o_pos-1)+T(o_pos+1,r);
else return E(l,o_pos-1)-T(o_pos+1,r);
}
bool Q(int l, int r){
int eq_pos = 0;
for(int i=l; i<=r; ++i){
if(e[i]=='=') eq_pos = i;
}
err = false;
ll L = E(l,eq_pos-1);
ll R = E(eq_pos+1,r);
return L==R;
}
int main(){
string s;
cin >>s;
int n = s.size();
set<char> a;
for(char c:s){
if(islower(c)||isupper(c)) a.insert(c);
}
if(a.size()>8){
cout << 0 << endl;
return 0;
}
string x = "01+-*()=";
sort(all(x));
set<string> valid;
set<string> check;
do{
auto itr = x.begin();
map<char,char> cv;
for(char c:a){
cv[c] = *itr;
++itr;
}
string t = s;
rep(i,n)if(cv.count(t[i])) t[i]=cv[t[i]];
int eq = 0;
rep(i,n) eq += (t[i]=='=');
if(eq!=1) continue;
e = t;
bool res = Q(0,e.size()-1);
if(!err && res) valid.insert(t);
if(!err) check.insert(t);
}while(next_permutation(all(x)));
// for(string V:valid) dbg(V);
// for(string C:check) dbg(C);
cout << valid.size() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char *s;
bool error;
bool equation();
int64_t expr();
int64_t mul();
int64_t unary();
int64_t num();
bool consume(char c){
if(*s != c) return false;
++s;
return true;
}
bool equation(){
error = false;
int64_t lhs, rhs;
lhs = expr();
if(error || !consume('=')) return false;
rhs = expr();
if(error || *s != '\0') return false;
return lhs == rhs;
}
int64_t expr(){
if(error) return 0;
int64_t value = mul();
while(*s == '+' || *s == '-'){
if(error) return 0;
if(consume('+')) value += mul();
else if(consume('-')) value -= mul();
}
return value;
}
int64_t mul(){
if(error) return 0;
int64_t value = unary();
while(consume('*')){
if(error) return 0;
value *= unary();
}
return value;
}
int64_t unary(){
if(error) return 0;
int64_t value;
if(consume('-')) return -unary();
else if(consume('(')){
value = expr();
if(!consume(')')) error = true;
return value;
}
else return num();
}
int64_t num(){
if(error) return 0;
int64_t value = 0;
switch(*s){
case '0':
++s;
return 0;
case '1':
while(*s == '0' || *s == '1'){
value = value * 2 + (*s - '0');
++s;
}
return value;
default:
error = true;
return 0;
}
}
int main(){
char code[32], *ss = new char[32];
map<char, int> decl;
int cnt = 0;
scanf("%s", code);
for(int i=0;i < 32 && code[i] != '\0';++i){
if('A' <= code[i] && code[i] <= 'Z' || 'a' <= code[i] && code[i] <= 'z'){
if(decl.count(code[i]) == 0) decl[code[i]] = cnt++;
}
}
if(cnt > 8){
printf("0\n");
return 0;
}
int ptn[] = {0, 1, 2, 3, 4, 5, 6, 7};
int64_t ans = 0;
do{
int i;
s = ss;
for(i=0;i < 32 && code[i] != '\0';++i){
if(decl.count(code[i])) s[i] = "01+-*()="[ptn[decl[code[i]]]];
else s[i] = code[i];
}
for(;i<32;++i) s[i] = '\0';
if(equation()) ++ans;
}while(next_permutation(ptn, ptn + 8));
int64_t fact[9];
fact[0] = 1;
for(int i=1;i<=8;++i) fact[i] = i * fact[i-1];
printf("%" PRId64 "\n", ans / fact[8-cnt]);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
bool flg;
int expr(string s,int& p);
int term(string s,int& p);
int factor(string s,int& p);
int number(string s,int& p);
int expr(string s,int& p){
int res=term(s,p);
while(p<(int)s.size()){
if(flg) return 0;
if(s[p]=='+'){
p++;
res+=term(s,p);
continue;
}
if(s[p]=='-'){
p++;
res-=term(s,p);
continue;
}
break;
}
return res;
}
int term(string s,int& p){
int res=factor(s,p);
while(p<(int)s.size()){
if(flg) return 0;
if(s[p]=='*'){
p++;
res*=factor(s,p);
continue;
}
break;
}
return res;
}
int factor(string s,int& p){
int res;
if(s[p]=='-'){
p++;
res=-factor(s,p);
}else if(s[p]=='('){
p++;
res=expr(s,p);
if(p>=(int)s.size()||s[p]!=')'){
flg=1;
return 0;
}
p++;
}else if(isdigit(s[p])){
res=number(s,p);
}else{
flg=1;
return 0;
}
return res;
}
int number(string s,int& p){
if(s[p]=='0'){
if(p+1<(int)s.size()&&isdigit(s[p+1])){
flg=1;
return 0;
}
p++;
return 0;
}
int res=0;
while(p<(int)s.size()&&isdigit(s[p])) res=res*2+s[p++]-'0';
return res;
}
bool check(string s){
if(s.size()==0) return 0;
int op=0;
for(int i=0;i<(int)s.size();i++){
if(s[i]=='(') op++;
if(s[i]==')') op--;
if(op<0) return 0;
}
if(op) return 0;
return 1;
}
//set<string> ss;
int Q(string s){
if(count(s.begin(),s.end(),'=')!=1) return 0;
int k=s.find('=');
string a=s.substr(0,k);
string b=s.substr(k+1,s.size()-(k+1));
if(!check(a)) return 0;
if(!check(b)) return 0;
//cout<<s<<endl;
//cout<<a<<" "<<b<<endl;
flg=0;
int p=0;
int x=expr(a,p);
//cout<<flg<<" "<<p<<" "<<x<<endl;
if(flg||p!=(int)a.size()) return 0;
p=0;
int y=expr(b,p);
//cout<<flg<<" "<<p<<" "<<y<<endl;
if(flg||p!=(int)b.size()) return 0;
//cout<<a<<" "<<b<<endl;
//cout<<x<<":"<<y<<endl;
return x==y;
}
int ans=0;
string l="01+-*()=";
void dfs(string s,int b){
bool f=1;
for(int i=0;i<(int)s.size();i++){
if(!isalpha(s[i])) continue;
f=0;
char c=s[i];
for(int j=0;j<(int)l.size();j++){
if((b>>j)&1) continue;
string t=s;
for(int k=0;k<(int)s.size();k++){
if(t[k]==c) t[k]=l[j];
}
dfs(t,b+(1<<j));
}
break;
}
if(f) ans+=Q(s);
}
signed main(){
string s;
cin>>s;
dfs(s,0);
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using State = string::const_iterator;
bool equation(State &itr);
int expr(State &itr);
int term(State &itr);
int factor(State &itr);
int number(State &itr);
bool valid;
void error(State &itr){
valid = false;
while(*itr){
itr++;
}
}
void next_char(State &itr, char expected){
if(*itr == expected){
itr++;
}else{
error(itr);
}
}
bool equation(State &itr){
int lhs = expr(itr);
next_char(itr, '=');
int rhs = expr(itr);
return lhs == rhs;
}
int expr(State &itr){
int res = term(itr);
while(1){
if(*itr == '+'){
itr++;
res += term(itr);
}else if(*itr == '-'){
itr++;
res -= term(itr);
}else{
break;
}
}
return res;
}
int term(State &itr){
int res = factor(itr);
while(1){
if(*itr == '*'){
itr++;
res *= factor(itr);
}else{
break;
}
}
return res;
}
int factor(State &itr){
int res;
if(*itr == '-'){
itr++;
res = -factor(itr);
}else if(*itr == '('){
next_char(itr, '(');
res = expr(itr);
next_char(itr, ')');
}else{
res = number(itr);
}
return res;
}
int number(State &itr){
if(isdigit(*itr)){
if(*itr == '0'){
itr++;
return 0;
}
int res = 0;
while(isdigit(*itr)){
res <<= 1;
res |= *itr-'0';
itr++;
}
return res;
}else{
error(itr);
return 0;
}
}
constexpr char chs[] = {'=','+','-','*','(',')','0','1'};
map<char,int> mp;
string s;
vector<char> v;
vector<bool> used;
string formula;
int rec(int n){
if(n==0){
State begin = formula.begin();
valid = true;
valid &= equation(begin);
valid &= begin == formula.end();
return (valid ? 1 : 0);
}
int res = 0;
if(isalpha(s[n-1])){
int idx = mp[s[n-1]];
if(v[idx] == '#'){
for(int i=0;i<8;i++){
if(!used[i]){
used[i] = true;
v[idx] = chs[i];
formula[n-1] = chs[i];
res += rec(n-1);
used[i] = false;
v[idx] = '#';
}
}
}
else{
formula[n-1] = v[idx];
res += rec(n-1);
}
}else{
formula[n-1] = s[n-1];
res = rec(n-1);
}
return res;
}
int main(){
cin >> s;
int n = 0;
for(auto c : s){
if(isalpha(c) && mp.find(c) == mp.end()){
mp[c] = n;
n++;
}
}
v.resize(n, '#');
used.resize(n, false);
formula.resize(s.size());
cout << rec(int(s.size())) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <stdexcept>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
string S;
int idx;
int N, M;
string alphas;
int curr;
void consume(char c) {
if(idx >= N) throw exception();
if(S[idx] != c) throw exception();
idx ++;
}
bool try_consume(char c) {
try {
consume(c);
} catch(...) {
return false;
}
return true;
}
int E();
int convert(string const& b) {
int n = b.size();
int ret = 0;
for(int i=0; i<n; i++) {
ret *= 2;
assert(isdigit(b[i]));
ret += b[i] - '0';
}
return ret;
}
string B() {
string ret;
while(1) {
if(S[idx] == '0') ret += '0';
else if(S[idx] == '1') ret += '1';
else break;
idx++;
}
return ret;
}
int Nu() {
if(try_consume('0')) return 0;
consume('1');
return convert("1" + B());
}
int F() {
if(try_consume('-')) {
return -F();
}
else if(try_consume('(')) {
int r = E();
consume(')');
return r;
}
else {
return Nu();
}
}
int T() {
int num1 = F();
while(try_consume('*')) {
int num2 = F();
num1 *= num2;
}
return num1;
}
int E() {
int term1 = T();
while(1) {
bool cont = 0;
while(try_consume('+')) {
cont = 1;
int term2 = T();
term1 += term2;
}
while(try_consume('-')) {
cont = 1;
int term2 = T();
term1 -= term2;
}
if(!cont) break;
}
return term1;
}
bool Q() {
int expr1 = E();
consume('=');
int expr2 = E();
return expr1 == expr2 && idx == N;
}
int main() {
string T = "01+-*()=";
sort(T.begin(), T.end());
string RS; cin >> RS;
N = RS.size();
for(auto c: RS) if(isalpha(c)) alphas.push_back(c);
sort(alphas.begin(), alphas.end());
alphas.erase(unique(alphas.begin(), alphas.end()), alphas.end());
M = alphas.size();
if(M > T.size()) {
cout << 0 << endl;
return 0;
}
int ans = 0;
set<string> st;
do {
S = RS;
rep(i, N) {
if(isalpha(S[i])) S[i] = T[alphas.find(S[i])];
}
if(!st.count(S)) {
st.insert(S);
idx = curr = 0;
try { ans += Q(); } catch (...) {}
}
} while(next_permutation(T.begin(), T.end()));
cout << ans << endl;
return 0;
} |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using i64 = int64_t;
char codes[] = "=01()-+*";
int l = 0;
int used[8];
int contain[256];
int ans = 0, cnt = 0;
int counter[8];
char mpc[8];
map<int, int> mp;
int ok = 1;
int cur = 0;
string s;
int expr();
char get(int i) {
if(i >= l) return '$';
if(contain[(int)s[i]] == -1) return s[i];
return mpc[mp[(int) s[i]]];
}
int number() {
int first = 1; char fc, c;
int val = 0;
c = get(cur);
if(c != '0' && c != '1') {
ok = 2;
}
while(1) {
c = get(cur);
if(c != '0' && c != '1') {
break;
}
if(first) fc = c;
else if(fc == '0') {
ok = 3;
}
val = 2*val + (c - '0');
first = 0;
cur ++;
}
return val;
}
int factor() {
char c = get(cur);
if(c == '-') {
cur++;
return -factor();
} else if(c == '(') {
cur++; // '('
if(get(cur) == ')') {
ok = 4;
}
int val = expr();
if(get(cur) != ')') {
ok = 5;
return val;
}
cur++; // ')'
return val;
}
return number();
}
int term() {
char c;
int res = 1;
while(1) {
if(get(cur) == '*') ok = 6;
res *= factor();
c = get(cur);
if(c == '*') {
cur++; // '*'
} else {
break;
}
}
return res;
}
int expr() {
int res = 0;
char c = 0, op = '+';
while(1) {
if(get(cur) == '+') {
ok = 7;
}
if(op == '+') {
res += term();
} else {
res -= term();
}
c = get(cur);
if(c == '+' || c == '-') {
op = c;
cur ++; // "+", "-"
} else {
break;
}
}
return res;
}
void check() {
//for(int i=0; i<l; ++i) {cout << get(i);}cout << endl;
cur = 0; ok = 1;
int left = expr();
if(get(cur) != '=') {
return;
}
cur++; // '='
int right = expr();
//cout << "result " << left << " - " << right << " cur " << cur << " ok " << ok<< endl;
if(cur == l && ok == 1) {
if(left == right) {
ans++;
}
}
}
// index c
void dfs(int c) {
if(c == cnt) {
check();
return;
}
for(int i=0; i<8; ++i) {
if(used[i]) continue;
if(i==0) {
if(counter[c] == 1) {
used[i] = 1;
mpc[c] = codes[i];
dfs(c+1);
used[i] = 0;
}
} else {
used[i] = 1;
mpc[c] = codes[i];
dfs(c+1);
used[i] = 0;
}
}
}
int main() {
cin >> s;
l = s.length();
for(int i=0; i<8; ++i) {
contain[(int) codes[i]] = -1;
}
for(int i=0; i<l; ++i) {
int v = (int) s[i];
if(contain[v] == -1) continue;
if(contain[v] == 0) {
contain[v] = 1;
mp[v] = cnt++;
counter[mp[v]] = 1;
} else {
counter[mp[v]] += 1;
}
}
if(cnt > 8) {
cout << 0 << endl;
} else {
dfs(0);
cout << ans << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
string temp = "01+-*()=";
int A(string&, int&);
int B(string&, int&);
int C(string&, int&);
int C(string& S, int& idx)
{
int ret = 0;
if(isdigit(S[idx])) {
if(isdigit(S[idx + 1]) && S[idx] == '0') throw (0LL);
while(isdigit(S[idx])) ret = ret * 2 + S[idx++] - '0';
} else if(S[idx] == '(') {
ret = A(S, ++idx);
if(S[idx] != ')') throw (0LL);
++idx;
} else if(S[idx] == '-') {
ret = -C(S, ++idx);
} else {
throw (0LL);
}
return (ret);
}
int B(string& S, int& idx)
{
int ret = C(S, idx);
while(S[idx] == '*') {
ret *= C(S, ++idx);
}
return (ret);
}
int A(string& S, int& idx)
{
int ret = B(S, idx);
while(S[idx] == '+' || S[idx] == '-') {
if(S[idx] == '+') ret += B(S, ++idx);
else ret -= B(S, ++idx);
}
return (ret);
}
signed main()
{
string S;
int conv[32];
memset(conv, -1, sizeof(conv));
cin >> S;
vector< char > num;
for(char& c : S) {
if(isalpha(c)) num.push_back(c);
}
sort(begin(num), end(num));
num.erase(unique(begin(num), end(num)), end(num));
for(int i = 0; i < S.size(); i++) {
if(isalpha(S[i])) conv[i] = lower_bound(begin(num), end(num), S[i]) - begin(num);
}
if(num.size() > temp.size()) {
cout << 0 << endl;
return (0);
}
sort(begin(temp), end(temp));
vector< string > ss;
do {
string T = S;
for(int i = 0; i < S.size(); i++) {
if(~conv[i]) T[i] = temp[conv[i]];
}
if(count(begin(T), end(T), '=') == 1 && T.front() != '=' && T.back() != '=') {
ss.push_back(T);
}
} while(next_permutation(begin(temp), end(temp)));
sort(begin(ss), end(ss));
ss.erase(unique(begin(ss), end(ss)), end(ss));
int ret = 0;
for(string& al : ss) {
string L = "", R = "";
bool which = false;
for(int i = 0; i < al.size(); i++) {
if(al[i] == '=') {
which = true;
continue;
}
(which ? R : L) += al[i];
}
R += "$";
L += "$";
int idx;
try {
int ll = A(L, idx = 0);
if(idx + 1 != L.size()) continue;
int rr = A(R, idx = 0);
if(idx + 1 != R.size()) continue;
ret += ll == rr;
} catch(int e) {}
}
cout << ret << endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef pair<string,string> P;
int bnf();
set<P> used;
map<char,int> M;
string S;
int idx,valid;
char ch[8]={'0','1','+','-','*','(',')','='};
int ord[8];
bool check(string a){//テ」ツつ、テ」ツつウテ」ツδシテ」ツδォテ」ツ?ョテヲツ閉ーテ」ツ?ィテ」ツつォテ」ツδε」ツつウテ」ツ?ョテ・ツッツセテ・ツソツ愿」ツつ津ァツ「ツコティツェツ?
int par=0;
for(char s:a){
par += (s == '(') - (s == ')');
if(s == '=') return 0;
if(par < 0) return 0;
}
return par==0;
}
//100-10*-(10+11*100)=100*1000
int getNum(){ //テヲツ鳴?・ツュツ療・ツ按療」ツつ津ヲツ閉ーテ・ツュツ療」ツ?ォテ」ツ?凖」ツつ?
int res = 0;
if(S[idx] == '0' && isdigit(S[idx+1])) valid = 0;
while(isdigit(S[idx]))res = res*2 + S[idx++]-'0';
return res;
}
int cal(){
char ch = S[idx];
int res = 0,sign = 1;
if(ch=='+'||ch=='*'||ch==')'){ valid = 0;return 0;}
while(S[idx] == '-') idx++, sign *= -1;
ch = S[idx];
if(isdigit(ch)){
res = sign*getNum();
if(S[idx] == '*'){idx++; return res * cal();}
return res;
}
else if(ch == '(') {
idx++;res = sign*bnf();idx++;
return res;
}
valid = 0;
return 0;
}
int bnf(){
int res = cal();
while(idx<(int)S.size()){
if(valid == 0) return -1;
char ch = S[idx];
if(ch == '('){valid = 0;}
else if(ch == '*'){idx++;res *= cal();}
else if(ch == '+'){idx++;res += cal();}
else if(ch == '-'){idx++;res -= cal();}
else if(ch != ')') valid = 0;
else break;
}
if(valid ==0) return -1;
return res;
}
string mkS(string a){
string res;
for(char s:a){
if(isalpha(s))res += ch[ ord[ M[s] ] ];
else res += s;
}
return res;
}
int calc(string A,string B){
if(A.size()==0 || B.size()==0) return 0;
if(used.count(P(A,B)))return 0;
used.insert(P(A,B));
valid = check(A) && check(B);
idx = 0;
S = A;
int ra = bnf();
idx = 0;
S = B;
int rb = bnf();
//if(valid)cout<<A<<"="<<B<<" "<<valid<<" "<<ra<<" "<<rb<<endl;
return ra == rb && valid;
}
int calc(string s){
s = mkS(s);
for(int i=0;i<(int)s.size();i++)
if(s[i]=='=') return calc(s.substr(0,i),s.substr(i+1,s.size()-i-1));
return 0;
}
int dfs(int num,string &s){
if(num == 8) return calc(s);
int res = 0;
for(int i=0;i<8;i++){
if(ord[i] != -1)continue;
ord[i] = num;
res +=dfs(num+1,s);
ord[i] = -1;
}
return res;
}
int main(){
string str;
cin>>str;
if(str.size()<3)cout<<0<<endl,exit(0);
map<char,int> cnt;
for(int i=0;i<(int)str.size();i++)if(isalpha(str[i]))cnt[str[i]]++;
if(cnt.size()>8)cout<<0<<endl,exit(0);
int c = 0;
for(pair<char,int> p:cnt)if(isalpha(p.first)) M[p.first] = c++;
memset(ord,-1,sizeof(ord));
cout<<dfs(0,str)<<endl;
return 0;
} |
#include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define FOR(i, a, n) for (int i = a; i < n; ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
// nPr の列挙
template <typename BidirectionalIterator>
inline bool next_partial_permutation(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last) {
reverse(middle, last);
return next_permutation(first, last);
}
bool Q(const string& s, int& i);
int E(const string& s, int& i, bool& ng);
int T(const string& s, int& i, bool& ng);
int F(const string& s, int& i, bool& ng);
int N(const string& s, int& i, bool& ng);
bool Q(const string& s, int& i) {
bool ng = false;
int val = E(s, i, ng);
if (ng || s[i] != '=') return false;
++i; // '='
ng = false;
int val2 = E(s, i, ng);
if (ng || i != s.size()) return false;
return (val == val2);
}
int E(const string& s, int& i, bool& ng) {
int val = T(s, i, ng);
while (s[i] == '+' || s[i] == '-') {
char op = s[i];
++i;
int val2 = T(s, i, ng);
if (op == '+') val += val2;
else val -= val2;
}
return val;
}
int T(const string& s, int& i, bool& ng) {
int val = F(s, i, ng);
while (s[i] == '*') {
++i;
int val2 = F(s, i, ng);
val *= val2;
}
return val;
}
int F(const string& s, int& i, bool& ng) {
if (isdigit(s[i])) return N(s, i, ng);
if (s[i] == '-') {
++i;
return -F(s, i, ng);
}
if (s[i] != '(') return (ng = true);
++i;
int val = E(s, i, ng);
if (s[i] != ')') return (ng = true);
++i;
return val;
}
int N(const string& s, int& i, bool& ng) {
if (s[i] == '0') {
++i;
return 0;
}
if (s[i] == '1') {
int val = 1;
++i;
while (s[i] == '0' || s[i] == '1') {
val = val * 2 + (s[i] - '0');
++i;
}
return val;
}
return (ng = true);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
const int n = s.size();
vector<char> alphabets;
for (char c : s) if (isalpha(c)) alphabets.push_back(c);
sort(alphabets.begin(), alphabets.end());
alphabets.erase(unique(alphabets.begin(), alphabets.end()), alphabets.end());
const int alphabets_size = alphabets.size();
string symbols = "()*+-01="; // ソート済み
int ans = 0;
do {
map<char, char> mp;
for (int i = 0; i < alphabets_size; ++i) {
mp[alphabets[i]] = symbols[i];
}
int equal_cnt = 0;
string t;
t.reserve(100);
t = s;
for (int i = 0; i < n; ++i) {
if (isalpha(s[i])) t[i] = mp[s[i]];
if (t[i] == '=') ++equal_cnt;
}
if (equal_cnt != 1) continue;
const int equal_pos = t.find('=');
int i = 0;
ans += Q(t, i);
} while (next_partial_permutation(symbols.begin(), symbols.begin() + alphabets_size, symbols.end()));
cout << ans << endl;
}
|
#include <bits/stdc++.h>
// Shrotening
#define fst first
#define snd second
#define pb push_back
// Loop
#define FOR(i,a,b) for(long i=(a);i<(b);++i)
#define RFOR(i,a,b) for(long i=(a);i>=(b);--i)
#define REP(i,a) for(long i=0;i<(a);++i)
#define RREP(i,a) for(long i=(a);i>=0;--i)
#define EACH(i,a) for(auto (i)=(a).begin(),_END=(a).end();i!=_END;++i)
#define REACH(i,a) for(auto (i)=(a).rbegin(),_END=(a).rend();i!=_END;++i)
//Algorithm
#define ALL(a) (a).begin(), a.end()
#define RALL(a) (a).rbegin(), a.rend()
#define EXIST(a,x) ((a).find(x)!=(a).end())
#define SORT(a) std::sort((a).begin(), (a).end())
#define UNIQUE(a) std::sort((a).begin(), a.end()), a.erase(std::unique((a).begin(), a.end()), a.end());
#define SUM(a) std::accumulate((a).begin(), (a).end(), 0);
//Setting
#define OPT std::cin.tie(0);std::ios::sync_with_stdio(false);
//debug message
bool debug = true;
#define MSG(s) if(debug){std::cout << s << std::endl;}
#define DEBUG(x) if(debug){std::cout << "debug(" << #x << "): " << x << std::endl;}
//alias
typedef long long LL;
typedef std::vector<char> VC;
typedef std::vector<int> VI;
typedef std::vector<long> VL;
typedef std::vector<long long> VLL;
typedef std::vector< VC > VC2;
typedef std::vector< VI > VI2;
typedef std::vector< VL > VL2;
typedef std::vector< VLL > VLL2;
typedef std::pair<int,int> PII;
typedef struct ParseState {
int pos;
int len;
std::string str;
std::deque<int> stack;
//EOF
bool isEOF() { return pos >= len; }
bool isNotEOF() { return pos < len; }
//advance
void eat(char ch) {
assert(pos < len && str[pos] == ch);
pos++;
}
char getCh() {
assert(pos < len);
return pos < len ? str[pos++] : -1;
}
//lookahead
char seek() {
return pos < len ? str[pos] : -1;
}
char seek(int offset) {
return (pos+offset) < len ? str[pos+offset] : -1;
}
//backtrack
void setBacktrack() { stack.push_front(pos); }
void delBacktrack() {
assert(!stack.empty());
stack.pop_front();
}
void backtrack() {
assert(!stack.empty());
pos = stack.front();
stack.pop_front();
}
//test
bool isDigit() {
return isDigit(0);
}
bool isDigit(int offset) {
char c = seek(offset);
return c >= '0' && c <= '9';
}
bool isUpperAlpha() {
return isUpperAlpha(0);
}
bool isUpperAlpha(int offset) {
char c = seek(offset);
return c >= 'A' && c <= 'Z';
}
bool isLowerAlpha() {
return isLowerAlpha(0);
}
bool isLowerAlpha(int offset) {
char c = seek(offset);
return c >= 'a' && c <= 'z';
}
//test2
bool isAlpha() {
return isLowerAlpha(0) || isUpperAlpha(0);
}
bool isAlpha(int offset) {
return isLowerAlpha(offset) || isUpperAlpha(offset);
}
bool isAlphaNum() {
return isLowerAlpha(0) || isUpperAlpha(0) || isDigit(0);
}
bool isAlphaNum(int offset) {
return isLowerAlpha(offset) || isUpperAlpha(offset) || isDigit(offset);
}
} State;
typedef std::pair<bool,int> RES;
bool parseQ(State* s);
RES parseE(State* s);
RES parseT(State* s);
RES parseF(State* s);
RES parseN(State* s);
bool parseQ(State* s) {
RES eres1 = parseE(s);
if(!eres1.first || s->seek() != '=') return false;
s->eat('=');
RES eres2 = parseE(s);
if(!eres2.first || s->isNotEOF()) return false;
return eres1.second == eres2.second;
}
//E ::= T|E+T|E???T
//E ::= T {(+|-) T}*
RES parseE(State* s) {
RES tres = parseT(s);
if(!tres.first) return tres;
int ans = tres.second;
while(s->seek() == '+' || s->seek() == '-') {
char op = s->getCh();
tres = parseT(s);
if(!tres.first) return tres;
ans += (op == '+' ? 1 : -1) * tres.second;
}
return std::make_pair(true, ans);
}
//T ::= F|T???F
//T ::= F ('*' F)*
RES parseT(State* s) {
RES fres = parseF(s);
if(!fres.first) return fres;
int ans = fres.second;
while(s->seek() == '*') {
s->eat('*');
fres = parseF(s);
if(!fres.first) return fres;
ans *= fres.second;
}
return std::make_pair(true, ans);
}
RES parseF(State* s) {
char c = s->seek();
if(c == '0' || c == '1') return parseN(s);
if(c == '-') {
s->eat('-');
auto fres = parseF(s);
fres.second *= -1;
return fres;
}
if(c == '(') {
s->eat('(');
auto eres = parseE(s);
if(!eres.first || s->seek() != ')') {
return std::make_pair(false, 0);
}
s->eat(')');
return eres;
}
return std::make_pair(false, 0);
}
RES parseN(State* s) {
if(s->seek() == '0' && (s->seek(1) == '0' || s->seek(1) == '1')) {
return std::make_pair(false, 0);
}
int v = 0;
while(s->isNotEOF()) {
char c = s->seek();
if(c != '0' && c != '1') {
break;
}
s->getCh();
v = (v << 1) + (int)(c - '0');
}
return std::make_pair(true, v);
}
VC symbol {{'0', '1', '+', '-', '*', '(', ')', '='}};
VI used(8, 0);
std::string chars;
int input_size;
int chars_size;
std::set< std::map<char,char> > pattern;
void dfs(int i, std::map<char,char>& map) {
if(i >= chars_size) {
pattern.insert(map);
return;
}
if(std::find(ALL(symbol), chars[i]) != symbol.end()) {
map[chars[i]] = chars[i];
dfs(i+1, map);
} else {
REP(j, 8) {
if(used[j] == 0) {
used[j] = 1;
map[chars[i]] = symbol[j];
dfs(i+1, map);
used[j] = 0;
}
}
}
}
int main() {
std::string input;
std::cin >> input;
input_size = input.size();
chars = input;
UNIQUE(chars);
chars_size = chars.size();
std::map<char,char> m;
dfs(0, m);
LL ans = 0;
for(auto p: pattern) {
std::string str = input;
REP(i, input_size) {
str[i] = p[str[i]];
}
State state = State{0, input_size, str};
if(parseQ(&state)) {
ans++;
}
}
std::cout << ans << std::endl;
} |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
char component_array[8] = {'0','1','+','-','*','(',')','=',};
int table[40320][8];
int num_of_type,table_index;
int calc_E(char line[32],int left,int right);
int calc_T(char line[32],int left,int right);
int calc_F(char line[32],int left,int right);
int calc_NUM(char line[32],int left,int right);
bool is_component(char ch){
for(int i = 0; i < 8; i++){
if(ch == component_array[i])return true;
}
return false;
}
void makeTable(bool used[8],int change_list[8],int index){
if(index == num_of_type){
for(int i = 0; i < num_of_type; i++){
table[table_index][i] = change_list[i];
}
table_index++;
return;
}
for(int i = 0; i < 8; i++){
if(used[i] == false){
bool next_used[8];
int next_change_list[8];
for(int k = 0; k < 8; k++)next_used[k] = used[k];
for(int k = 0; k < index; k++)next_change_list[k] = change_list[k];
next_used[i] = true;
next_change_list[index] = i;
makeTable(next_used,next_change_list,index+1);
}
}
}
bool is_OK(char work[32]){
int length;
for(length = 0; work[length] != '\0'; length++);
int equal_count = 0;
for(int i = 0; work[i] != '\0'; i++){
if(work[i] == '=')equal_count++;
}
if(equal_count != 1)return false;
int eq_pos;
for(int i = 0; i < length; i++){
if(work[i] == '='){
eq_pos = i;
break;
}
}
if(eq_pos == 0 || eq_pos == length-1)return false;
for(int i = 0; i < length; i++){
if(work[i] == '(' && work[i+1] == ')')return false;
if(work[i] == ')' && work[i+1] == '(')return false;
}
stack<int> S;
for(int i = 0; i < eq_pos; i++){
if(work[i] == '(')S.push(i);
else if(work[i] == ')'){
if(S.size() == 0)return false;
else{
S.pop();
}
}
}
if(S.size() > 0)return false;
for(int i = eq_pos+1; i < length; i++){
if(work[i] == '(')S.push(i);
else if(work[i] == ')'){
if(S.size() == 0)return false;
else{
S.pop();
}
}
}
if(S.size() > 0)return false;
if(work[0] == '+' || work[0] == '*')return false;
if(work[eq_pos+1] == '+' || work[eq_pos+1] == '*')return false;
for(int i = 0; i < length; i++){
if((work[i] == '0' || work[i] == '1') && work[i+1] == '(')return false;
if((work[i] == '(') && (work[i+1] == '*' || work[i+1] == '+'))return false;
}
for(int i = 0; work[i] != '\0';){
if(work[i] != '0' && work[i] != '1')i++;
else{
if(work[i] == '1'){
while(work[i] == '1' || work[i] == '0')i++;
}else{
if(work[i+1] == '1' || work[i+1] == '0')return false;
i++;
}
}
}
for(int i = 0; work[i] != '\0'; i++){
if((work[i] == '+' || work[i] == '*') &&
(work[i+1] == '+' || work[i+1] == '*' || work[i+1] == '='|| work[i+1] == ')' || work[i+1] == '\0'))return false;
if((work[i] == '-') &&
(work[i+1] == '+' || work[i+1] == '*' || work[i+1] == '=' || work[i+1] == ')' || work[i+1] == '\0'))return false;
}
return true;
}
int calc_E(char line[32],int left,int right){
int depth = 0;
queue<int> Q;
for(int i = left; i <= right; ){
if(line[i] == '(')depth++;
else if(line[i] == ')')depth--;
if(depth != 0){
i++;
}else if(line[i] != '+' && line[i] != '-'){
i++;
}else{
if(line[i] == '+'){
Q.push(i);
i++;
}else{ //line[i] == '-'
if((i != left) && (line[i-1] == '0' || line[i-1] == '1' || line[i-1] == ')')){
Q.push(i);
}
while(i <=right && line[i] == '-')i++;
}
}
}
if(Q.empty()){
return calc_T(line,left,right);
}
int tmp = calc_E(line,left,Q.front()-1),tmp_right;
if(tmp == BIG_NUM)return BIG_NUM;
while(!Q.empty()){
int loc = Q.front();
Q.pop();
if(Q.empty()){
tmp_right = calc_T(line,loc+1,right);
}else{
tmp_right = calc_T(line,loc+1,Q.front()-1);
}
if(tmp_right == BIG_NUM){
return BIG_NUM;
}
if(line[loc] == '+'){
tmp += tmp_right;
}else{
tmp -= tmp_right;
}
}
return tmp;
}
int calc_T(char line[32],int left,int right){
int depth = 0;
queue<int> Q;
for(int i = left; i <= right; ){
if(line[i] == '(')depth++;
else if(line[i] == ')')depth--;
if(depth != 0){
i++;
}else if(line[i] != '*'){
i++;
}else{
Q.push(i);
i++;
}
}
if(Q.empty()){
return calc_F(line,left,right);
}
int tmp = calc_T(line,left,Q.front()-1),tmp_right;
if(tmp == BIG_NUM)return BIG_NUM;
while(!Q.empty()){
int loc = Q.front();
Q.pop();
if(Q.empty()){
tmp_right = calc_F(line,loc+1,right);
}else{
tmp_right = calc_F(line,loc+1,Q.front()-1);
}
if(tmp_right == BIG_NUM){
return BIG_NUM;
}
tmp *= tmp_right;
}
return tmp;
}
int calc_F(char line[32],int left,int right){
if(line[left] == '1' || line[left] == '0'){
return calc_NUM(line,left,right);
}else if(line[left] == '-'){
return -1*calc_F(line,left+1,right);
}else if(line[left] == '('){
int depth = 0;
int close_pos = BIG_NUM;
for(int i = left; i <= right; i++){
if(line[i] == '(')depth++;
else if(line[i] == ')'){
depth--;
if(depth == 0){
close_pos = i;
break;
}
}
}
if(close_pos == BIG_NUM || close_pos != right)return BIG_NUM;
return calc_E(line,left+1,close_pos-1);
}else{
return BIG_NUM;
}
}
int calc_NUM(char line[32],int left,int right){
for(int i = left; i <= right; i++){
if(line[i] != '0' && line[i] != '1')return BIG_NUM;
}
int ret = 0;
for(int i = left; i <= right; i++){
ret = 2*ret+line[i]-'0';
}
return ret;
}
int main(){
char buf[32];
scanf("%s",buf);
int check_table[128];
for(int i = 0; i < 128; i++)check_table[i] = 0;
vector<int> CHAR_LIST,REPLACE_LOC[128];
num_of_type = 0;
for(int i = 0; buf[i] != '\0'; i++){
if(!is_component(buf[i])){
REPLACE_LOC[buf[i]].push_back(i);
if(check_table[buf[i]] == 0){
num_of_type++;
check_table[buf[i]]++;
CHAR_LIST.push_back(buf[i]);
}
}
}
if(num_of_type > 8){
printf("0\n");
return 0;
}
char work[32],left_table[32],right_table[32];
int eq_pos,left_result,right_result,right_length,ans = 0;
if(num_of_type == 0){
if(!is_OK(buf)){
printf("0\n");
return 0;
}
for(int i = 0; buf[i] != '\0'; i++){
if(buf[i] == '='){
eq_pos = i;
break;
}
left_table[i] = buf[i];
left_table[i+1] = '\0';
}
right_length = 0;
for(int i = 0; buf[eq_pos+1+i] != '\0'; i++){
right_table[i] = buf[eq_pos+1+i];
right_length++;
right_table[i+1] = '\0';
}
left_result = calc_E(left_table,0,eq_pos-1);
if(abs(left_result) == BIG_NUM){
printf("0\n");
return 0;
}
right_result = calc_E(right_table,0,right_length-1);
if(left_result == right_result){
printf("1\n");
}else{
printf("0\n");
}
return 0;
}
bool first_used[8];
for(int i = 0; i < 8; i++)first_used[i] = false;
int first_change_list[8];
table_index = 0;
makeTable(first_used,first_change_list,0);
for(int i = 0; i < table_index; i++){
for(int k = 0; buf[k] != '\0'; k++){
work[k] = buf[k];
work[k+1] = '\0';
}
for(int k = 0; k < num_of_type; k++){
int word = CHAR_LIST[k];
for(int a = 0; a < REPLACE_LOC[word].size(); a++){
int loc = REPLACE_LOC[word][a];
work[loc] = component_array[table[i][k]];
}
}
if(!is_OK(work))continue;
for(int i = 0; work[i] != '\0'; i++){
if(work[i] == '='){
eq_pos = i;
break;
}
left_table[i] = work[i];
left_table[i+1] = '\0';
}
right_length = 0;
for(int i = 0; work[eq_pos+1+i] != '\0'; i++){
right_table[i] = work[eq_pos+1+i];
right_length++;
right_table[i+1] = '\0';
}
left_result = calc_E(left_table,0,eq_pos-1);
if(abs(left_result) == BIG_NUM)continue;
right_result = calc_E(right_table,0,right_length-1);
if(abs(right_result) == BIG_NUM)continue;
if(left_result == right_result){
ans++;
}
}
printf("%d\n",ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define FOR(i,bg,ed) for(int i=(bg);i<(ed);i++)
#define REP(i,n) FOR(i,0,n)
string S="()01+-*=";
bool flag=false;
#define NONE -1
int n;
string s;
int F(int &id);
int E(int &id,int sgn);
int getnum(int &id){
int cnt=0,num=0;
bool firstzero=s[id]=='0';
while(id<n&&(s[id]=='0'||s[id]=='1')){
num*=2;
num+=(s[id]-'0');
id++;
cnt++;
}
if(firstzero&&cnt>1){
flag=false;
}
return num;
}
int F(int &id){
if(id<n){
if(s[id]=='0'||s[id]=='1')return getnum(id);
else if(s[id]=='('){
id++;
int num=E(id,1);
if(id<n&&s[id]==')'){
id++;
return num;
}
}
else if(s[id]=='-'){
id++;
return -F(id);
}
}
flag=false;
return 0;
}
int T(int &id){
int sum=1;
if(s[id]=='('||s[id]=='-'||s[id]=='0'||s[id]=='1')sum*=F(id);
else{
flag=false;
return 0;
}
if(!flag)return false;
if(id==n||s[id]==')'||s[id]=='='||s[id]=='+'||s[id]=='-'){
return sum;
}
if(s[id]=='*'){
id++;
return sum*T(id);
}
else{
flag=false;
return 0;
}
}
int E(int &id,int sgn){
int sum=0;
if(s[id]=='('||s[id]=='-'||s[id]=='0'||s[id]=='1')sum=sgn*T(id);
else{
flag=false;
return 0;
}
if(!flag)return false;
if(id==n||s[id]==')'||s[id]=='='){
return sum;
}
if(s[id]=='+'){
id++;
return sum+E(id,1);
}
else if(s[id]=='-'){
id++;
return sum+E(id,-1);
}
else{
flag=false;
return 0;
}
}
bool Q(){
int L,R;flag=true;
int eq=NONE,id;
REP(i,n){
if(s[i]=='='){
if(eq==NONE)
eq=i;
else
return false;
}
}
if(eq==NONE)return false;
L=E(id=0,1);
if(!flag||id!=eq)return false;
R=E(id=eq+1,1);
if(!flag||id!=n)return false;
return L==R;
}
int main(){
flag=true;
map<char,int> m;
string input;
cin>>input;
n=input.size();
s=input;
REP(i,n){
bool exist=false;
REP(j,8)if(s[i]==S[j])exist=true;
if(!exist)m[s[i]]=0;
}
int cnt=0;
for(auto &it:m)it.second=cnt++;
if(cnt>8){
cout<<0<<endl;
return 0;
}
set<string> all;
vector<int> ord(8);
iota(ord.begin(),ord.end(),0);
do{
REP(i,n){
if(m.count(input[i]))
s[i]=S[ord[m[input[i]]]];
}
all.insert(s);
}while(next_permutation(ord.begin(),ord.end()));
int res=0;
for(auto &it:all){
s=it;
if(Q())res++;
}
cout<<res<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef pair<LL, LL> PLL;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
return is >> p.FF >> p.SS;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9+7;
int Q(int&);
int E(int&);
int T(int&);
int F(int&);
string S;
int N;
int err = 0;
string gs;
int Q(int& p){
int l = E(p);
if(err || p >= N || gs[p] != '='){
err = 1;
return 0;
}
++p;
int r = E(p);
if(err || p != N){
err = 1;
return 0;
}
return l == r;
}
int E(int& p){
int x = T(p);
while(p < N){
if(gs[p] == '+'){
++p;
x += T(p);
}
else if(gs[p] == '-'){
++p;
x -= T(p);
}
else
break;
}
return x;
}
int T(int& p){
int x = F(p);
while(p < N){
if(gs[p] == '*'){
++p;
x *= F(p);
}
else
break;
}
return x;
}
int F(int& p){
if(err || p >= N){
err = 1;
return 0;
}
int x = 0;
if(gs[p] == '-'){
++p;
x = -F(p);
}
else if(gs[p] == '('){
++p;
x = E(p);
if(gs[p] != ')'){
err = 1;
return 0;
}
++p;
}
else if(gs[p] == '0'){
x = 0;
++p;
}
else if(gs[p] == '1'){
x = 1;
++p;
while(p<N){
if(gs[p] == '0')
x *= 2;
else if(gs[p] == '1')
x = x*2 + 1;
else
break;
++p;
}
}
else{
err = 1;
return 0;
}
return x;
}
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> S;
N = SZ(S);
set<char> s;
REP(i,N)
if(('a' <= S[i] && S[i] <= 'z') || ('A' <= S[i] && S[i] <= 'Z'))
s.insert(S[i]);
if(SZ(s) > 8){
cout << 0 << endl;
return 0;
}
char cs[9] = "+-*=()01";
sort(cs, cs+8);
set<string> ans;
do{
string tmp = S;
int j = 0;
REP(i,N){
char c = tmp[i];
if(('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')){
REP(k,N)
if(tmp[k] == c)
tmp[k] = cs[j];
++j;
}
}
int p = 0;
err = 0;
gs = tmp;
int flag = Q(p);
if(flag && !err)
ans.insert(gs);
}while(next_permutation(cs, cs+8));
cout << SZ(ans) << endl;
//for(auto&&s:ans)cout<<s<<endl;
return 0;
} |
#include <cstdio>
#include <algorithm>
#include <vector>
#include <map>
#include <functional>
#include <iostream>
#include <set>
#include <cstring>
using namespace std;
typedef long long ll;
#define SIZE 500010
#define INF 1000000000
int term(char* &s);
int number(char* &s);
int factor(char* &s);
int expr(char* &s);
int term(char* &s){
int res = factor(s), r;
if(res == -INF) return res;
while(1){
if(*s == '*'){
r = factor(++s);
if(r == -INF) return r;
res *= r;
}else{
break;
}
}
return res;
}
int number(char* &s){
int res = 0;
if(!(*s)) return -INF;
if(!('0' <= *s && *s <= '1')) return -INF;
if(*s == '0' && (*(s+1) == '0' || *(s+1) == '1')) return -INF;
while('0' <= *s && *s <= '1')
res = res*2 + (*s++ - '0');
return res;
}
int factor(char* &s){
if(*s == ')') return -INF;
if(*s == '-'){
int r = factor(++s);
if(r == -INF) return r;
return r * -1;
}
if(*s != '(') return number(s);
int res = expr(++s);
if(*s != ')') return -INF;
s++;
return res;
}
int expr(char* &s) {
int res = term(s), r;
if(res == -INF) return res;
while(1){
if(*s == '+'){
r = term(++s);
if(r == -INF) return r;
res += r;
}else if(*s == '-'){
r = term(++s);
if(r == -INF) return r;
res -= r;
}else{
if(*s == '(') return -INF;
break;
}
}
return res;
}
bool check(char *s){
int counter = 0;
while(*s){
counter += (*s == '(') - (*s == ')');
if(counter < 0) return false;
s++;
if(*s == ')' && (*(s+1) == '1' || *(s+1) == '0')) return false;
}
return counter == 0;
}
bool isop(char x){
return x == '*' || x == '-' || x == '+' || x == '=' ||
x == '(' || x == ')' || x == '0' || x == '1';
}
int main(){
char s[50];
vector<char> vec;
map<char,int> dic;
scanf("%s", s);
for(int i=0;s[i];i++){
if(!isop(s[i]))
vec.push_back(s[i]);
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
//for(int i=0;i<vec.size();i++) cerr << vec[i] << endl;
if(vec.size() > 8){
puts("0");
return 0;
}
for(int i=0;i<vec.size();i++) dic[vec[i]] = i;
char op[] = "01+-*()=";
sort(op, op+8);
int n = strlen(s);
int ans = 0;
char d[50];
d[n] = '\0';
set<string> ss;
do{
string r = op;
r = r.substr(0, vec.size());
if(ss.find(r) != ss.end()) continue;
ss.insert(r);
int eq = -1;
for(int i=0;s[i];i++){
if(isop(s[i])) d[i] = s[i];
else d[i] = op[dic[s[i]]];
if(d[i] == '='){
if(eq == -1) eq = i;
else eq = -2;
}
}
if(eq < 0 || eq == 0 || eq == n-1) continue;
d[eq] = '\0';
char *p = d, *q = d + eq + 1;
if(!check(p) || !check(q)) continue;
int res1 = expr(p);
int res2 = expr(q);
//if(res1 != -INF) cerr << d << endl;
//if(res2 != -INF) cerr << d + eq + 1 << endl;
if(res1 != -INF && res1 == res2){
ans++;
d[eq] = '=';
}
}while(next_permutation(op, op+8));
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
#include <stdexcept>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
string S;
int idx;
int N, M;
string alphas;
int curr;
void consume(char c) {
if(idx >= N) throw std::logic_error("failed consuming");
if(S[idx] != c) throw std::logic_error("failed consuming");
idx ++;
}
bool try_consume(char c) {
try {
consume(c);
} catch(std::logic_error const& e) {
return false;
}
return true;
}
int E();
int convert(string const& b) {
int n = b.size();
int ret = 0;
for(int i=0; i<n; i++) {
ret *= 2;
assert(isdigit(b[i]));
ret += b[i] - '0';
}
return ret;
}
string B() {
string ret;
while(1) {
if(S[idx] == '0') ret += '0';
else if(S[idx] == '1') ret += '1';
else break;
idx++;
}
return ret;
}
int Nu() {
if(try_consume('0')) return 0;
consume('1');
return convert("1" + B());
}
int F() {
if(try_consume('-')) {
return -F();
}
else if(try_consume('(')) {
int r = E();
consume(')');
return r;
}
else {
return Nu();
}
}
int T() {
int num1 = F();
while(try_consume('*')) {
int num2 = F();
num1 *= num2;
}
return num1;
}
int E() {
int term1 = T();
while(1) {
bool cont = 0;
while(try_consume('+')) {
cont = 1;
int term2 = T();
term1 += term2;
}
while(try_consume('-')) {
cont = 1;
int term2 = T();
term1 -= term2;
}
if(!cont) break;
}
return term1;
}
bool Q() {
int expr1 = E();
consume('=');
int expr2 = E();
return expr1 == expr2 && idx == N;
}
int main() {
string T = "01+-*()=";
sort(T.begin(), T.end());
string RS; cin >> RS;
N = RS.size();
for(auto c: RS) if(isalpha(c)) alphas.push_back(c);
sort(alphas.begin(), alphas.end());
alphas.erase(unique(alphas.begin(), alphas.end()), alphas.end());
M = alphas.size();
if(M > T.size()) {
cout << 0 << endl;
return 0;
}
int ans = 0;
set<string> st;
do {
S = RS;
rep(i, N) {
if(isalpha(S[i])) S[i] = T[alphas.find(S[i])];
}
if(!st.count(S)) {
st.insert(S);
idx = curr = 0;
try { ans += Q(); } catch (std::logic_error const& e) {}
}
} while(next_permutation(T.begin(), T.end()));
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
bool error = false;
string errorName = "";
int errorIndex = -1;
bool Q(string& s, int& index);
int E(string& s, int& index);
int T(string& s, int& index);
int F(string& s, int& index);
int N(string& s, int& index);
bool Q(string& s, int& index){
int l = E(s, index);
if(error){
return false;
}
if(s[index] != '='){
errorName = "Qnot=";
errorIndex = index;
return false;
}
index++;
int r = E(s, index);
if(error){
return false;
}
if(s[index] != '#'){
errorName = "Qend2";
errorIndex = index;
return false;
}
return (l == r);
}
int E(string& s, int& index){
int ret = T(s, index);
if(error){
return -1;
}
while(true){
if(s[index] == '+'){
index++;
int temp = T(s, index);
if(error){
return -1;
}
ret += temp;
}
else if(s[index] == '-'){
index++;
int temp = T(s, index);
if(error){
return -1;
}
ret -= temp;
}
else{
break;
}
}
return ret;
}
int T(string& s, int& index){
int ret = F(s, index);
if(error){
return -1;
}
while(true){
if(s[index] == '*'){
index++;
int temp = F(s, index);
if(error){
return -1;
}
ret *= temp;
}
else{
break;
}
}
return ret;
}
int F(string& s, int& index){
if(s[index] == '-'){
index++;
int f = F(s, index);
if(error){
return -1;
}
return -f;
}
else if(s[index] == '('){
index++;
int ret = E(s, index);
if(error){
return -1;
}
if(index == (int)s.size() || s[index] != ')'){
error = true;
errorName = "Fnot)";
errorIndex = index;
return -1;
}
index++;
return ret;
}
int ret = N(s, index);
if(error){
return -1;
}
return ret;
}
int N(string& s, int& index){
if(s[index] == '0'){
index++;
return 0;
}
else if(s[index] == '1'){
index++;
int ret = 1;
while(index != (int)s.size() && isdigit(s[index])){
ret *= 2;
ret += s[index] - '0';
index++;
}
return ret;
}
else{
error = true;
errorName = "Nend2";
errorIndex = index;
return -1;
}
}
int main(){
string s;
cin >> s;
set<char> cSet;
for(char c: s){
if(('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z')){
cSet.insert(c);
}
}
vector<char> cList(cSet.begin(), cSet.end());
int cSize = (int)cList.size();
if(cSize > 8){
cout << 0 << endl;;
}
else{
int ans = 0;
char replaceList[] = {'0', '1', '+', '-', '*', '(', ')', '='};
vector<int> com(8, 0);
for(int i = 0; i < cSize; i++){
com[8 - i - 1] = 1;
}
vector<int> order(cSize);
for(int i = 0; i < cSize; i++){
order[i] = i;
}
do{
vector<char> useList;
for(int i = 0; i < 8; i++){
if(com[i] == 1){
useList.push_back(replaceList[i]);
}
}
do{
string temp = s + '#';
for(int i = 0; i < cSize; i++){
replace(temp.begin(), temp.end(), cList[i], useList[order[i]]);
}
int begin = 0;
error = false;
errorName = "";
bool isOk = Q(temp, begin);
if(isOk){
ans++;
}
else{
if(errorName != "Qnot="){
//cout << temp << " " << errorName << " " << errorIndex << endl;
}
}
}while(next_permutation(order.begin(), order.end()));
}while(next_permutation(com.begin(), com.end()));
cout << ans << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using i64 = int64_t;
bool Q(string s, int idx);
pair<i64, int> E(string s, int idx);
pair<deque<i64>, int> E_(string s, int idx);
pair<i64, int> T(string s, int idx);
pair<i64, int> T_(string s, int idx);
pair<i64, int> F(string s, int idx);
pair<string, int> N(string s, int idx);
pair<string, int> B(string s, int idx);
bool error = false;
string letters = "01+-*()=";
i64 to_i64(string s){
i64 res = 0;
for(int i=0;i<s.size();++i){
res *= 2;
res += s[i] - '0';
}
return res;
}
bool Q(string s, int idx){
auto p = E(s, idx);
if(error || s[idx+p.second] != '=')return false;
auto p2 = E(s, idx+p.second+1);
if(error || p.first != p2.first || p.second+p2.second+1 != s.size())return false;
else return true;
}
pair<i64, int> E(string s, int idx){
auto p = T(s, idx);
if(error){
return make_pair(-1, -1);
}
auto p2 = E_(s, idx+p.second);
if(error)return make_pair(-1, -1);
i64 res = p.first;
for(auto e: p2.first)res += e;
return make_pair(res, p.second+p2.second);
}
pair<deque<i64>, int> E_(string s, int idx){
if(idx >= s.size())return make_pair(deque<i64>(), 0);
if(s[idx] == '+' || s[idx] == '-'){
auto p = T(s, idx+1);
if(error)return make_pair(deque<i64>(), -1);
auto p2 = E_(s, idx+p.second+1);
if(error)return make_pair(deque<i64>(), -1);
deque<i64> res = p2.first;
if(s[idx] == '+'){
res.push_front(p.first);
return make_pair(res, p.second+p2.second+1);
}else{
res.push_front(-p.first);
return make_pair(res, p.second+p2.second+1);
}
}
return make_pair(deque<i64>(), 0);
}
pair<i64, int> T(string s, int idx){
auto p = F(s, idx);
if(error){
return make_pair(-1, -1);
}
auto p2 = T_(s, idx+p.second);
if(error)return p2;
if(p2.second == 0)p2.first = 1;
return make_pair(p.first*p2.first, p.second+p2.second);
}
pair<i64, int> T_(string s, int idx){
if(idx >= s.size())return make_pair(0, 0);
if(s[idx] == '*'){
auto p = F(s, idx+1);
if(error)return p;
auto p2 = T_(s, idx+p.second+1);
if(error)return p2;
if(p2.second == 0)p2.first = 1;
return make_pair(p.first*p2.first, p.second+p2.second+1);
}
return make_pair(0, 0);
}
pair<i64, int> F(string s, int idx){
if(s[idx] == '-'){
auto p = F(s, idx+1);
return make_pair(-p.first, p.second+1);
}
if(s[idx] == '('){
auto p = E(s, idx+1);
if(s[idx+p.second+1] != ')'){
error = true;
return make_pair(-1, -1);
}
return make_pair(p.first, p.second+2);
}
if(s[idx] == '1' || s[idx] == '0'){
auto p = N(s, idx);
i64 n = to_i64(p.first);
return make_pair(n, p.second);
}
error = true;
return make_pair(-1, -1);
}
pair<string, int> N(string s, int idx){
if(s[idx] == '0')return make_pair("0", 1);
if(s[idx] == '1'){
auto p = B(s, idx+1);
return make_pair("1"+p.first, 1+p.second);
}
error = true;
return make_pair("", -1);
}
pair<string, int> B(string s, int idx){
if(idx >= s.size())return make_pair("", 0);
if(s[idx] == '0'){
auto p = B(s, idx+1);
return make_pair("0"+p.first, 1+p.second);
}
if(s[idx] == '1'){
auto p = B(s,idx+1);
return make_pair("1"+p.first, 1+p.second);
}
return make_pair("", 0);
}
int main(){
string s;
cin >> s;
set<char> st;
for(auto c: s){
bool f = false;
for(auto cc: letters)
if(cc == c){
f = true;
break;
}
if(f)continue;
st.insert(c);
}
if(st.size() > 8){
cout << 0 << endl;
return 0;
}
vector<char> v;
for(auto c: st)v.push_back(c);
while(v.size() < 8)v.push_back('#');
sort(v.begin(), v.end());
int ans = 0;
do{
string q;
for(auto c: s){
bool flag = false;
for(int i=0;i<v.size();++i){
if(c == v[i]){
q.push_back(letters[i]);
flag = true;
break;
}
}
if(!flag)q.push_back(c);
}
error = false;
bool f = Q(q, 0);
if(f)ans++;
//if(f)cout << q << endl;
}while(next_permutation(v.begin(), v.end()));
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define all(x) x.begin(),x.end()
using namespace std;
typedef long long ll;
const ll LLINF = LLONG_MAX;
const string opr = "01+-*=()";
string context;
int n;
ll parse_E(int&,string&);
ll parse_F(int &p,string &s) {
if( p >= (int)s.size() ) throw "fail";
if( s[p] == '+' ) throw "fail";
if( s[p] == '-' ) {
++p;
ll v;
try { v = parse_F(p,s); } catch(...) { throw "fail"; }
return v * -1LL;
}
if( s[p] == '(' ) {
++p;
ll v;
try { v = parse_E(p,s); } catch(...) { throw "fail"; }
if( p >= (int)s.size() ) throw "fail";
if( s[p] != ')' ) throw "fail";
++p;
if( p < (int)s.size() && ( s[p] == '0' || s[p] == '1' ) ) throw "fail";
return v;
}
int cnt = 0;
ll v = 0;
bool first_zero = ( s[p] == '0' );
while( p < (int)s.size() && ( s[p] == '0' || s[p] == '1' ) ) {
v <<= 1;
v += (ll)( s[p] - '0' );
++p;
++cnt;
}
if( first_zero && cnt != 1 ) throw "fail";
if( cnt == 0 ) throw "fail";
if( p < (int)s.size() && s[p] == '(' ) throw "fail";
return v;
}
ll parse_T(int &p,string &s) {
ll v;
try { v = parse_F(p,s); } catch(...) { throw "fail"; }
while( p < (int)s.size() && s[p] == '*' ) {
++p;
ll tmp;
try { tmp = parse_T(p,s); } catch(...) { throw "fail"; }
v *= tmp;
}
return v;
}
ll parse_E(int &p,string &s) {
ll v;
try { v = parse_T(p,s); } catch(...) { throw "fail"; }
while( p < (int)s.size() && ( s[p] == '+' || s[p] == '-' ) ) {
char op = s[p];
++p;
ll tmp;
try { tmp = parse_T(p,s); } catch(...) { throw "fail"; }
if( op == '+' ) v += tmp;
if( op == '-' ) v -= tmp;
}
return v;
}
bool pari_check(string &s) {
int cnt = 0;
rep(i,(int)s.size()) {
if( s[i] == '(' ) ++cnt;
if( s[i] == ')' ) --cnt;
if( cnt < 0 ) return false;
}
return cnt == 0;
}
bool check() {
string s,t;
{
string tmp;
tmp = context;
rep(i,n) if( context[i] == '=' ) tmp[i] = ' ';
vector<string> vec;
stringstream ss;
ss << tmp;
while( ss >> s ) vec.push_back(s);
if( vec.size() != 2 ) return false;
s = vec[0];
t = vec[1];
}
if( !pari_check(s) || !pari_check(t) ) return false;
int p = 0;
ll sv,tv;
try {
sv = parse_E(p,s);
p = 0;
tv = parse_E(p,t);
} catch(...) {
return false;
}
if( sv == LLINF || tv == LLINF) return false;
return sv == tv;
}
int dfs(int ptr,int used,vector<char> &already) {
if( n <= ptr ) return check();
if( !isalpha(context[ptr]) ) return dfs(ptr+1,used,already);
int sum = 0;
int v = context[ptr] - 'a';
if( already[v] != '$' ) {
if( already[v] == '=' ) return 0;
char tmp = context[ptr];
context[ptr] = already[v];
sum += dfs(ptr+1,used,already);
context[ptr] = tmp;
return sum;
}
rep(i,(int)opr.size()) {
if( ( used >> i ) & 1 ) continue;
char tmp = context[ptr];
context[ptr] = opr[i];
already[v] = opr[i];
sum += dfs(ptr+1,used|(1<<i),already);
already[v] = '$';
context[ptr] = tmp;
}
return sum;
}
bool normalize() {
vector<char> vec;
rep(i,(int)context.size()) if( isalpha(context[i]) ) vec.push_back(context[i]);
sort(all(vec));
vec.erase(unique(all(vec)),vec.end());
rep(i,(int)context.size()) if( isalpha(context[i]) ) {
int pos = lower_bound(all(vec),context[i]) - vec.begin();
context[i] = (char)('a'+pos);
}
return (int)vec.size() <= 8;
}
void compute() {
if( !normalize() ) { puts("0"); return; }
n = (int)context.size();
int used = 0;
rep(i,n) if( context[i] == '=' ) { used = (1<<5); break; }
vector<char> vec(8,'$');
cout << dfs(0,used,vec) << endl;
}
int main() {
if( 0 ) {
string s;
cin >> s;
int p = 0;
cout << parse_E(p,s) << endl;
return 0;
}
cin >> context;
compute();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount
#define INF INT_MAX
string s,t;
int n;
vector<char> cs,match;
string cand="01+-*()=";
bool used[10];
int res=0;
int calc_e(int& l,int term);
int calc_f(int& l,int term){
if(l>=term)return -INF;
if(isdigit(t[l])){
int v=0;
if(t[l]=='0'&&l+1<term&&isdigit(t[l+1]))return -INF;
while(l<term&&isdigit(t[l])){
v<<=1;
v+=t[l]-'0';
l++;
}
return v;
}else if(t[l]=='-'){
l++;
int v=calc_f(l,term);
if(v==-INF)return -INF;
return -v;
}else if(t[l]=='('){
l++;
int v=calc_e(l,term);
if(v==-INF||t[l]!=')')return -INF;
l++;
return v;
}else{
return -INF;
}
}
int calc_t(int& l,int term){
if(l>=term)return -INF;
int v=calc_f(l,term);
if(v==-INF||l>term)return -INF;
while(l<term&&t[l]=='*'){
l++;
int nv=calc_f(l,term);
if(nv==-INF)return -INF;
v*=nv;
}
return v;
}
int calc_e(int& l,int term){
if(l>=term)return -INF;
int v=calc_t(l,term);
if(v==-INF||l>term)return -INF;
while(l<term&&(t[l]=='+'||t[l]=='-')){
if(t[l]=='+'){
l++;
int nv=calc_t(l,term);
if(nv==-INF)return -INF;
v+=nv;
}else if(t[l]=='-'){
l++;
int nv=calc_t(l,term);
if(nv==-INF)return -INF;
v-=nv;
}
}
return v;
}
void dfs(int i){
if(i==cs.size()){
t="";
rep(j,s.size()){
if(exist(cand,s[j])){
t+=s[j];
continue;
}
rep(k,cs.size()){
if(s[j]==cs[k]){
t+=match[k];
break;
}
}
}
int cnt=0;
rep(j,t.size()){
if(t[j]=='=')cnt++;
}
if(cnt!=1)return ;
rep(j,t.size()){
if(t[j]=='='){
int l=0,r=j+1;
int cntc=0;
bool ok=true;
repl(k,l,j){
if(t[k]=='(')cntc++;
if(t[k]==')')cntc--;
if(cntc<0)ok=false;
}
if(cntc!=0)ok=false;
cntc=0;
repl(k,r,n){
if(t[k]=='(')cntc++;
if(t[k]==')')cntc--;
if(cntc<0)ok=false;
}
if(cntc!=0)ok=false;
if(!ok)break;
int vl=calc_e(l,j); int vr=calc_e(r,n);
if(l==j&&r==n&&vl!=-INF&&vr!=-INF&&vl==vr){
res++;
}
break;
}
}
return ;
}
rep(j,cand.size()){
if(used[j])continue;
used[j]=true;
match.push_back(cand[j]);
dfs(i+1);
match.pop_back();
used[j]=false;
}
}
int main(){
cin>>s;
n=s.size();
rep(i,n){
if(exist(cand,s[i]))continue;
cs.push_back(s[i]);
}
sort(all(cs));
uni(cs);
if(cs.size()>8){
cout<<0<<endl;
return 0;
}
dfs(0);
cout<<res<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define ALL(V) (V).begin(),(V).end()
#define ALLR(V) (V).rbegin(),(V).rend()
#define endl '\n'
using namespace std;
using ll = int64_t;
using ull = uint64_t;
using PLL = pair<ll, ll>;
using TLL = tuple<ll, ll, ll>;
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
bool success;
bool Q(const string &S, ll &idx);
ll E(const string &S, ll &idx);
ll T(const string &S, ll &idx);
ll F(const string &S, ll &idx);
ll N(const string &S, ll &idx);
// ll B(const string &S, ll &idx);
bool calc(const string &S) {
ll idx = 0;
success = true;
return Q(S, idx);
}
bool Q(const string &S, ll &idx) {
ll left = E(S, idx);
if(!success) return false;
if(!(idx < S.size() && S[idx] == '=')) return false;
idx++;
ll right = E(S, idx);
return idx == S.size() && success && left == right;
}
ll E(const string &S, ll &idx) {
ll ret = T(S, idx);
while(true) {
if(S.size() <= idx) break;
if(S[idx] == '+') {
idx++;
ll r = T(S, idx);
ret += r;
} else if(S[idx] == '-') {
idx++;
ll r = T(S, idx);
ret -= r;
} else {
if(!(S[idx] == '=' || S[idx] == ')')) success = false;
break;
}
}
if(!success) return 0;
return ret;
}
ll T(const string &S, ll &idx) {
ll ret = F(S, idx);
while(true) {
if(S.size() <= idx) break;
if(S[idx] == '*') {
idx++;
ll r = F(S, idx);
ret *= r;
} else {
if(!(S[idx] == '+' || S[idx] == '-' || S[idx] == '=' || S[idx] == ')')) success = false;
break;
}
}
if(!success) return 0;
return ret;
}
bool is_digit(char c) { return c == '0' || c == '1'; };
ll F(const string &S, ll &idx) {
if(S.size() <= idx) {
success = false;
return 0;
}
if(is_digit(S[idx])) return N(S, idx);
if(S[idx] == '-') {
idx++;
return -F(S, idx);
}
if(S[idx] == '(') {
idx++;
ll ret = E(S, idx);
if(!(idx < S.size() && S[idx] == ')')) success = false;
else idx++;
return ret;
}
success = false;
return 0;
}
ll N(const string &S, ll &idx) {
static auto check = [](char c) {
return (c == '=' ||
c == '+' ||
c == '-' ||
c == '*' ||
c == ')');
};
if(!is_digit(S[idx])) {
success = false;
return 0;
}
if(S[idx] == '0') {
idx++;
return 0;
}
ll ret = S[idx] - '0';
idx++;
while(true) {
if(idx == S.size()) break;
if(is_digit(S[idx])) {
ret = ret * 2 + (S[idx] - '0');
idx++;
} else {
if(!check(S[idx])) success = false;
break;
}
}
return ret;
}
ll alp2idx(char c) {
if('a' <= c && c <= 'z') return c - 'a';
if('A' <= c && c <= 'Z') return c - 'A' + 26;
assert(false);
}
int main() {
string S;
cin >> S;
ll cnt = 0;
V<char> alp_lis;
for(char c : S) {
if('a' <= c && c <= 'z') alp_lis.push_back(c);
if('A' <= c && c <= 'Z') alp_lis.push_back(c);
}
{
sort(ALL(alp_lis));
auto ite = unique(ALL(alp_lis));
alp_lis.erase(ite, alp_lis.end());
}
V<char> op_lis = { '0', '1', '+', '-', '*', '=', '(', ')' };
if(op_lis.size() < alp_lis.size()) {
cout << 0 << endl;
return 0;
}
sort(ALL(op_lis));
ll chr_idx[52] = {};
ll ans = 0;
for(ll i = 0; i < alp_lis.size(); i++) chr_idx[alp2idx(alp_lis[i])] = i;
do {
auto T = S;
for(char &c : T) {
if(!(('a' <= c && c <= 'z') ||
('A' <= c && c <= 'Z'))) continue;
ll idx = chr_idx[alp2idx(c)];
c = op_lis[idx];
}
auto tmp = calc(T);
ans += tmp;
// if(tmp) cout << T << endl;
} while(next_permutation(ALL(op_lis)));
for(ll i = 1; i < op_lis.size() - alp_lis.size(); i++) ans /= (i + 1);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int64)1e9
#define REP(i, n) for(int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for(int64 i = (a); i < (b); i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint32_t;
using int64 = int64_t;
using uint64 = uint64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
template<typename A, typename B> inline void chmin(A &a, B b) { if (a > b) a = b; }
template<typename A, typename B> inline void chmax(A &a, B b) { if (a < b) a = b; }
#define double long double
#define EPS (1e-4)
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define PI 3.141592653589793238
struct Point3D{
double x,y,z;
Point3D(){}
Point3D(double x,double y,double z):x(x),y(y),z(z){}
Point3D operator+(Point3D p) {return Point3D(x+p.x,y+p.y,z+p.z);}
Point3D operator-(Point3D p) {return Point3D(x-p.x,y-p.y,z-p.z);}
Point3D operator*(double k){return Point3D(x*k,y*k,z*k);}
Point3D operator/(double k){return Point3D(x/k,y/k,z/k);}
Point3D operator*(Point3D p){
return Point3D(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);
}
double operator^(Point3D p){
return x*p.x+y*p.y+z*p.z;
}
double norm(){return x*x+y*y+z*z;}
double abs(){return sqrt(norm());}
bool operator < (const Point3D &p) const{
if(x!=p.x) return x<p.x;
if(y!=p.y) return y<p.y;
return z<p.z;
}
bool operator == (const Point3D &p) const{
return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS && fabs(z-p.z)<EPS;
}
};
istream &operator >> (istream &is,Point3D &p){
is>>p.x>>p.y>>p.z;
return is;
}
ostream &operator << (ostream &os,Point3D p){
os<<fixed<<setprecision(12)<<p.x<<" "<<p.y<<" "<<p.z;
return os;
}
typedef Point3D Vector3D;
typedef vector<Point3D> Polygon3D;
struct Segment3D{
Point3D p1,p2;
Segment3D(){}
Segment3D(Point3D p1, Point3D p2):p1(p1),p2(p2){}
};
typedef Segment3D Line3D;
istream &operator >> (istream &is,Segment3D &s){
is>>s.p1>>s.p2;
return is;
}
struct Sphere{
Point3D c;
double r;
Sphere(){}
Sphere(Point3D c,double r):c(c),r(r){}
};
istream &operator >> (istream &is,Sphere &c){
is>>c.c>>c.r;
return is;
}
double norm(Vector3D a){
return a.x*a.x+a.y*a.y+a.z*a.z;
}
double abs(Vector3D a){
return sqrt(norm(a));
}
double dot(Vector3D a,Vector3D b){
return a.x*b.x+a.y*b.y+a.z*b.z;
}
Vector3D cross(Vector3D a,Vector3D b){
return Vector3D(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x);
}
Point3D project(Line3D l,Point3D p){
Point3D b=l.p2-l.p1;
double t=dot(p-l.p1,b)/norm(b);
return l.p1+b*t;
}
Point3D reflect(Line3D l,Point3D p){
return p+(project(l,p)-p)*2.0;
}
double getDistanceLP(Line3D l,Point3D p){
return abs(cross(l.p2-l.p1,p-l.p1)/abs(l.p2-l.p1));
}
double getDistanceSP(Segment3D s,Point3D p){
if(dot(s.p2-s.p1,p-s.p1) < 0.0 ) return abs(p-s.p1);
if(dot(s.p1-s.p2,p-s.p2) < 0.0 ) return abs(p-s.p2);
return getDistanceLP(s,p);
}
bool intersectSC(Segment3D s,Sphere c){
double d=getDistanceSP(s,c.c);
if(d>c.r) return 0;
return !((abs(s.p1-c.c)<=c.r)&&(abs(s.p2-c.c)<=c.r));
}
struct ConvexHull3D{
struct face{
int a,b,c;
bool ok;
face(){}
face(int a,int b,int c,bool ok):a(a),b(b),c(c),ok(ok){}
};
int n,num;
vector<Point3D> p;
vector<face> f;
vector<vector<int> > g;
ConvexHull3D(int n):n(n),p(n),f(n*8),g(n,vector<int>(n)){}
void input(){
for(int i=0;i<n;i++) cin>>p[i];
}
double dblcmp(Point3D q,face f){
Point3D m=p[f.b]-p[f.a];
Point3D n=p[f.c]-p[f.a];
Point3D t=q-p[f.a];
return (m*n)^t;
}
void deal(int q,int a,int b){
int idx=g[a][b];
face add;
if(f[idx].ok){
if(dblcmp(p[q],f[idx])>EPS) dfs(q,idx);
else{
add=face(b,a,q,1);
g[q][b]=g[a][q]=g[b][a]=num;
f[num++]=add;
}
}
}
void dfs(int q,int now){
f[now].ok=0;
deal(q,f[now].b,f[now].a);
deal(q,f[now].c,f[now].b);
deal(q,f[now].a,f[now].c);
}
void build(){
num=0;
if(n<4) return;
bool flg=1;
for(int i=1;i<n;i++){
if(abs(p[0]-p[i])>EPS){
swap(p[1],p[i]);
flg=0;
break;
}
}
if(flg) return;
flg=1;
for(int i=2;i<n;i++){
if(abs((p[0]-p[1])*(p[1]-p[i]))>EPS){
swap(p[2],p[i]);
flg=0;
break;
}
}
if(flg) return;
flg=1;
for(int i=3;i<n;i++){
if(abs(((p[0]-p[1])*(p[1]-p[2]))^(p[0]-p[i]))>EPS){
swap(p[3],p[i]);
flg=0;
break;
}
}
if(flg) return;
face add;
for(int i=0;i<4;i++){
add=face((i+1)%4,(i+2)%4,(i+3)%4,1);
if(dblcmp(p[i],add)>0) swap(add.b,add.c);
g[add.a][add.b]=g[add.b][add.c]=g[add.c][add.a]=num;
f[num++]=add;
}
for(int i=4;i<n;i++){
for(int j=0;j<num;j++){
if(f[j].ok&&dblcmp(p[i],f[j])>EPS){
dfs(i,j);
break;
}
}
}
int tmp=num;
num=0;
for(int i=0;i<tmp;i++)
if(f[i].ok) f[num++]=f[i];
}
double volume(Point3D a,Point3D b,Point3D c,Point3D d){
return ((b-a)*(c-a))^(d-a);
}
bool same(int s,int t){
Point3D &a=p[f[s].a];
Point3D &b=p[f[s].b];
Point3D &c=p[f[s].c];
return (abs(volume(a,b,c,p[f[t].a]))<EPS)
&& (abs(volume(a,b,c,p[f[t].b]))<EPS)
&& (abs(volume(a,b,c,p[f[t].c]))<EPS);
}
int polygon(){
int res=0;
for(int i=0;i<num;i++){
int flg=1;
for(int j=0;j<i;j++)
flg&=!same(i,j);
res+=flg;
}
return res;
}
int triangle(){
return num;
}
double area(Point3D a,Point3D b,Point3D c){
return abs((b-a)*(c-a));
}
Point3D cross(Point3D a,Point3D b,Point3D c){
return Point3D((b.y-a.y)*(c.z-a.z)-(b.z-a.z)*(c.y-a.y),
(b.z-a.z)*(c.x-a.x)-(b.x-a.x)*(c.z-a.z),
(b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x));
}
double area(){
double res=0;
if(n==3){
Point3D q=cross(p[0],p[1],p[2]);
res=abs(q)/2.0;
return res;
}
return res;
for(int i=0;i<num;i++)
res+=area(p[f[i].a],p[f[i].b],p[f[i].c]);
return res/2.0;
}
};
int64 N(int64& d, const string &s="") {
int64 ret = s[d]-'0';
d++;
while (d < s.size() && (s[d] == '0' || s[d] == '1')) {
if (ret == 0) return -INF_LL;
ret = (ret << 1) + s[d] -'0';
d++;
}
return ret;
}
int64 E(int64&, const string&);
int64 F(int64& d, const string &s="") {
if (s[d] == '-') {
d++;
int64 ret = F(d, s);
// cout << "F_-_d " << ret << " " << d << endl;
if (ret == -INF_LL) return ret;
return -ret;
} else if (s[d] == '(') {
d++;
int64 ret = E(d, s);
if (s[d] != ')') return -INF_LL;
d++;
return ret;
} else if (s[d] == '0' || s[d] == '1'){
return N(d, s);
} else {
return -INF_LL;
}
}
int64 T(int64& d, const string &s="") {
int64 ret = F(d, s);
// cout << "T_d " << ret << " " << d << endl;
if (ret == -INF_LL) return -INF_LL;
while (d < s.size() && s[d] == '*') {
d++;
int64 r = F(d, s);
if (r == -INF_LL) return r;
ret *= r;
}
return ret;
}
int64 E(int64& d, const string &s="") {
int64 ret = T(d, s);
if (ret == -INF_LL) return ret;
// cout << "E_d " << ret << " " << d << endl;
while (d < s.size() && (s[d] == '+' || s[d] == '-')) {
if (s[d] == '+') {
d++;
int64 r = T(d, s);
if (r == -INF_LL) return r;
ret += r;
} else if (s[d] == '-') {
d++;
int64 r = T(d, s);
if (r == -INF_LL) return r;
ret -= r;
}
}
return ret;
}
bool ok(int64 d = 0, const string &s="") {
int64 lhs = E(d, s);
// cout << "ok" << lhs << endl;
if (lhs == -INF_LL) return 0;
// cout << "ok_d " << d << endl;
if (s[d] != '=') return 0;
d++;
int64 rhs = E(d, s);
// cout << "ok" << rhs << endl;
if (rhs == -INF_LL || d != s.size()) return 0;
return (lhs == rhs);
}
int main(void) {
string s;
string symbol = "=+-*()01";
cin >> s;
string chs = "";
REP(i, s.size()) {
if (symbol.find(s[i]) == string::npos && chs.find(s[i]) == string::npos) {
chs += s[i];
}
}
vector<int> idx(symbol.size(), -1);
REP(i, chs.size()) {
idx[symbol.size() - chs.size() + i] = i;
}
int64 res = 0;
do {
string t = "";
char cvt[256] = {};
REP(i, idx.size()) {
if (idx[i] != -1) {
cvt[chs[idx[i]]] = symbol[i];
}
}
REP(i, s.size()) {
if (symbol.find(s[i]) == string::npos) {
t += cvt[s[i]];
} else {
t += s[i];
}
}
// cout << t << " " << ok(0, t) << endl;
if (ok(0, t)) {
// cout << t << endl;
res++;
}
} while (next_permutation(all(idx)));
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ret_type = double;
constexpr ret_type eps = 1e-8;
ret_type expr(string const& s, int& p);
ret_type term(string const& s, int& p);
ret_type factor(string const& s, int& p);
ret_type number(string const& s, int& p);
ret_type expr(string const& s, int& p) {
ret_type val = term(s, p);
while(p < (int)s.size() && (s[p] == '+' || s[p] == '-')) {
if(s[p] == '-') {
val -= term(s, ++p);
} else {
val += term(s, ++p);
}
}
return val;
}
ret_type term(string const& s, int& p) {
ret_type val = factor(s, p);
while(p < (int)s.size() && s[p] == '*') {
val *= factor(s, ++p);
}
return val;
}
ret_type factor(string const& s, int& p) {
if(s[p] == '-') {
return -factor(s, ++p);
} else if(s[p] == '(') {
ret_type res = expr(s, ++p);
if(p >= (int)s.size() || s[p] != ')') throw std::logic_error("");
++p;
return res;
} else if(isdigit(s[p])) {
return number(s, p);
} else {
throw std::logic_error("");
}
}
ret_type number(string const& s, int& p) {
if(s[p] != '0' && s[p] != '1') throw std::logic_error("");
if(p + 1 < (int)s.size() && s[p] == '0' && isdigit(s[p + 1])) throw std::logic_error("");
ret_type res = 0;
while(p < (int)s.size() && isdigit(s[p])) {
res *= 2;
res += (s[p++] == '1');
}
return res;
}
int main() {
string s;
cin >> s;
const int n = s.size();
vector<char> cs;
for(auto c : s) {
if(isalpha(c)) {
cs.push_back(c);
}
}
sort(begin(cs), end(cs));
cs.erase(unique(begin(cs), end(cs)), end(cs));
vector<char> v = {'0', '1', '+', '-', '*', '=', '(', ')'};
sort(begin(v), end(v));
if(cs.size() > v.size()) {
cout << 0 << endl;
return 0;
}
int ans = 0;
set<string> checked;
do {
string t;
for(auto c : s) {
if(isalpha(c)) {
t += v[find(begin(cs), end(cs), c) - begin(cs)];
} else {
t += c;
}
}
if(count(begin(t), end(t), '=') != 1) continue;
int lp = 0, rp = find(begin(t), end(t), '=') - begin(t) + 1;
if(rp == 1 || rp == n || checked.count(t) == 1) continue;
checked.insert(t);
try {
auto lval = expr(t, lp), rval = expr(t, rp);
if(t[lp] == '=' && rp == n && abs(lval - rval) < eps) {
ans += 1;
}
} catch(...) {
continue;
}
} while(next_permutation(begin(v), end(v)));
cout << ans << endl;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <cassert>
using namespace std;
#define int long long
typedef pair<bool, int> P;
string letters = "01+-*()=";
string s;
class Equation {
string s;
public:
void init(string s) {
this->s = s;
}
//[l, r)
bool Q(int l, int r) {
int i;
int cnt = 0;
for (i = l; i < r; i++) cnt += (s[i] == '=');
if (cnt != 1) return false;
for (i = l; i < r; i++) {
if (s[i] == '=') break;
}
P res1 = E(l ,i); if (!res1.first) return false;
P res2 = E(i + 1, r); if (!res2.first) return false;
//cout << res1.second << " " << res2.second << endl;
return (res1.second == res2.second);
}
P E(int l, int r) {
if (l >= r) return P(false, 0);
if (T(l, r).first) return T(l, r);
int lv = 0, i;
for (i = r - 1; i >= l; i--) {
if (s[i] == ')') lv++;
if (s[i] == '(') lv--;
if (lv == 0 && (s[i] == '+' || s[i] == '-')) {
P res1 = E(l, i); if (!res1.first) continue;
P res2 = T(i + 1, r); if (!res2.first) continue;
if (s[i] == '+') return P(true, res1.second + res2.second);
return P(true, res1.second - res2.second);
}
}
return P(false, 0);
}
P T(int l, int r) {
if (l >= r) return P(false, 0);
int lv = 0, i;
for (int i = r - 1; i >= l; i--) {
if (s[i] == ')') lv++;
if (s[i] == '(') lv--;
if (lv == 0 && s[i] == '*') {
P res1 = T(l, i); if (!res1.first) return P(false, 0);
P res2 = F(i + 1, r); if (!res2.first) return P(false, 0);
return P(true, res1.second * res2.second);
}
}
return F(l, r);
}
P F(int l, int r) {
if (l >= r) return P(false, 0);
if (s[l] == '(' && s[r - 1] == ')') return E(l + 1, r - 1);
if (s[l] == '-') {
P res = F(l + 1, r);
return P(res.first, -res.second);
}
return N(l, r);
}
P N(int l, int r) {
if (l >= r) return P(false, 0);
for (int i = l; i < r; i++) if (s[i] != '0' && s[i] != '1') return P(false, 0);
if (s[l] == '0') {
if (r - l == 1) return P(true, 0);
return P(false, 0);
}
int val = 0;
for (int i = l; i < r; i++) {
val *= 2;
val += s[i] - '0';
}
return P(true, val);
}
};
Equation equation;
signed main() {
cin >> s;
bool used[256] = {false};
int toId[256];
int uCnt = 0;
for (int i = 0; i < s.length(); i++) {
if (used[s[i]] == false) {
used[s[i]] = true;
int j;
for (j = 0; j < 8; j++) if (letters[j] == s[i]) break;
if (j < 8) { toId[s[i]] = -1; } //?????????????????¢
else { toId[s[i]] = uCnt++; }
}
if (uCnt > 8) {
cout << 0 << endl;
return 0;
}
}
set<string> dict;
vector<int> perm;
for (int i = 0; i < 8; i++) perm.push_back(i);
do {
string letters2;
for (int i = 0; i < 8; i++) {
letters2 += letters[perm[i]];
}
string ss; //??????????????????
for (int i = 0; i < s.length(); i++) {
if (toId[s[i]] == -1) { ss += s[i]; }
else { ss += letters2[toId[s[i]]]; }
}
dict.insert(ss);
} while (next_permutation(perm.begin(), perm.end()));
int ans = 0;
for (set<string>::iterator it = dict.begin(); it != dict.end(); it++) {
equation.init((*it));
if (equation.Q(0, (*it).length())) { ans++; }
}
cout << ans << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
constexpr int SIZE=8;
string symbol="01+-*()=";
using Flag=bitset<SIZE>;
using Er=runtime_error;
using ll=long long;
ll E(int &p,string &exp);
ll N(int &p,string &exp){
char dig=exp[p++];
if(dig=='0') return 0;
ll res=1;
while(p<exp.size() && isdigit(exp[p])){
res*=2;
res+=(exp[p++]-'0');
}
return res;
}
ll F(int &p,string &exp){
if(p>=exp.size()) throw Er("F_iter");
if(isdigit(exp[p])){
return N(p,exp);
}
if(exp[p]=='-'){
p++;
return -(F(p,exp));
}
if(exp[p]=='('){
p++;
ll res=E(p,exp);
if(p>=exp.size() || exp[p]!=')') throw Er("F_par");
p++;
return res;
}
throw Er("F_no "+to_string(p));
}
ll T(int &p,string &exp){
ll res=F(p,exp);
while(p<exp.size() && exp[p]!='=' && exp[p]!='+' && exp[p]!='-' && exp[p]!=')'){
char op=exp[p++];
if(op!='*') throw Er("T "+to_string(p));
ll rhs=F(p,exp);
res*=rhs;
}
return res;
}
ll E(int &p,string &exp){
ll res=T(p,exp);
while(p<exp.size() && exp[p]!='=' && exp[p]!=')'){
char op=exp[p++];
if(op!='+' && op!='-') throw Er("E");
ll rhs=T(p,exp);
if(op=='+') res+=rhs;
else res-=rhs;
}
return res;
}
bool Q(int &p,string& exp){
try{
ll lhs=E(p,exp);
if(p>=exp.size() || exp[p]!='=') return false;
p++;
ll rhs=E(p,exp);
if(p!=exp.size()) return false;
else{
return lhs==rhs;
}
}
catch(std::runtime_error re){
// cerr<<re.what()<<endl;
return false;
}
}
int judge(string exp){
int p=0;
return Q(p,exp);
}
int dfs(int p,string str,map<char,char> mp,Flag used){
if(p==str.size()){
return judge(str);
}
if(find(symbol.begin(),symbol.end(),str[p])!=symbol.end()){
return dfs(p+1,str,mp,used);
}
if(mp.count(str[p])){
str[p]=mp[str[p]];
return dfs(p+1,str,mp,used);
}
int res=0;
char org=str[p];
for(int i=0;i<SIZE;i++){
if(!used[i]){
used[i]=true;
mp[str[p]]=symbol[i];
str[p]=symbol[i];
res+=dfs(p+1,str,mp,used);
str[p]=org;
mp.erase(org);
used[i]=false;
}
}
return res;
}
int solve(string str){
map<char,char> mp;
return dfs(0,str,mp,Flag());
}
int main(){
string str;
cin>>str;
cout<<solve(str)<<endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#define rep(i,n) for(int i=0; i<(n); i++)
#define rrep(i,n) for(int i=(n)-1; i>=0; i--)
#define all(X) (X).begin(),(X).end()
using namespace std;
typedef long long int ll;
typedef pair<int,int> pii;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class A, size_t N, class T> void Fill(A (&a)[N], const T &v){ fill( (T*)a, (T*)(a+N), v ); }
const int INF = 0x3fffffff;
bool flag;
int B(string &s, int &n){
int ret = 0;
while(1){
if( !isdigit(s[n]) ){ break; }
else if( s[n] == '0' ){ n++; ret<<=1; }
else if( s[n] == '1' ){ n++; ret<<=1; ret += 1; }
}
//cout << "B " << ret << " " << flag << endl;
return ret;
}
int N(string &s, int &n){
if( !isdigit(s[n]) ){ flag = false; }
else if( s[n] == '0' ){ n++; return 0; }
else if( s[n] == '1' ){ return B(s, n); }
//cout << "flag N" << endl;
return 0;
}
int E(string &s, int &n, int ret=0, int d=1);
int F(string &s, int &n){
int ret;
if( isdigit(s[n]) ){ ret = N(s, n); }
else if( s[n] == '-' ){ n++; ret = -F(s, n); }
else if( s[n] == '(' ){
n++;
ret = E(s, n);
if( s[n] == ')' ) n++;
else flag = false;
} else {
//cout << "flag F" << endl;
flag = false;
}
//cout << "F " << ret << " " << flag << endl;
return ret;
}
int T(string &s, int &n){
int ret = F(s,n);
if( s[n] == '*' ){ n++; ret *= T(s, n); }
//cout << "T " << ret << " " << flag << endl;
return ret;
}
int E(string &s, int &n, int ret, int d){
ret += T(s,n) * d;
if( s.size() <= n ){}
else if( s[n] == '+' ){ n++; ret = E(s, n, ret, 1); }
else if( s[n] == '-' ){ n++; ret = E(s, n, ret, -1); }
//cout << "E " << ret << " " << flag << endl;
return ret;
}
bool Q(string &s){
flag = true;
int n=0;
int l = E(s,n);
//cout << "l = " << l << endl;
if( s[n] == '=' ) n++;
else return false;
int r = E(s,n);
//cout << "r = " << r << endl;
if( s[n] != '$' ) flag = false;
return flag && l == r;
}
string ope = "01+-*()=";
int main(){
set<string> ans;
string S;
cin >> S;
vector<char> v;
for(char c: S){
if( 'A' <= c && c <= 'Z' ) v.push_back(c);
if( 'a' <= c && c <= 'z' ) v.push_back(c);
}
sort(all(v));
v.erase( unique(all(v)), v.end() );
if( v.size() > 8 ){
cout << 0 << endl;
return 0;
}
sort( all(ope) );
do{
char mp[127]={};
rep(i,v.size()) mp[v[i]] = ope[i];
string s;
for(char c: S) s += (mp[c] ? mp[c] : c);
s += '$';
//cout << s << endl;
if( Q(s) ) ans.insert(s);
}while( next_permutation(all(ope)) );
//for(auto p: ans) cout << p << endl;
cout << ans.size() << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
string s[2];
string::iterator p;
int fact();
int term();
int exp();
int k;
bool f[2];
int fact() {
int x;string num;
int mi=1;
while(*p=='-') {
mi*=-1;
++p;
}
while(isdigit(*p)){num+=*p;++p;}
if(num.size()>1&&num[0]=='0') f[k]=0;
if(num.size()) {
x=0;
for(int i=num.size()-1,j=0; i>=0; i--,j++) x+=(1<<j)*(num[i]=='1');
} else if(p!=s[k].end()){
if(*p!='(') f[k]=0;
if(p!=s[k].end())++p;
x=exp();
if(*p!=')') f[k]=0;
if(p!=s[k].end())++p;
} else f[k]=0;
return x*mi;
}
int term() {
int x=fact();
while(*p=='*') {
++p;
x*=fact();
}
return x;
}
int exp() {
int x=term();
while(*p=='+'||*p=='-') {
if(*p=='+') {
++p;
x+=term();
} else {
++p;
x-=term();
}
}
return x;
}
int main() {
string r="01+-*()=";
sort(r.begin(),r.end());
string t;
cin >> t;
map<char,int> m;
for(int i=0; i<t.size(); i++) {
if(isalpha(t[i])&&!m.count(t[i])) {
int x=m.size();
m[t[i]]=x;
}
}
if(m.size()>r.size()) {
cout << 0 << endl;
return 0;
}
set<string> se;
do {
string e=t;
for(int i=0; i<e.size(); i++) {
if(isalpha(e[i])) e[i]=r[m[e[i]]];
}
int c=0;
for(int i=0; i<e.size(); i++) {
if(e[i]=='=') c++;
}
if(c!=1) continue;
c=0;
s[0]=s[1]="";
for(int i=0; i<e.size(); i++) {
if(e[i]=='=') {
c++;
continue;
}
s[c]+=e[i];
}
if(!s[0].size()||!s[1].size()) continue;
int x[2]={0,0};
for(k=0; k<2; k++) {
f[k]=1;
p=s[k].begin();
int d=0,z=0;
for(int i=0; i<s[k].size(); i++) {
if(isdigit(s[k][i])) z++;
if(s[k][i]=='(') {
d++;
if(i&&(isdigit(s[k][i-1])||s[k][i-1]==')')) f[k]=0;
if(i!=s[k].size()-1&&(!isdigit(s[k][i+1])&&s[k][i+1]!='('&&s[k][i+1]!='-')) f[k]=0;
}
if(s[k][i]==')') {
d--;
if(i&&(!isdigit(s[k][i-1])&&s[k][i-1]!=')')) f[k]=0;
if(i!=s[k].size()-1&&isdigit(s[k][i+1])) f[k]=0;
}
if(i) {
if(s[k][i]=='+'||s[k][i]=='*') {
if(s[k][i-1]=='+'||s[k][i-1]=='*'||s[k][i-1]=='-') f[k]=0;
}
} else if(s[k][i]=='+'||s[k][i]=='*') f[k]=0;
if(d<0) f[k]=0;
}
if(d||!z) f[k]=0;
if(f[k]) x[k]=exp();
}
if(f[0]&&f[1]&&x[0]==x[1]) {
se.insert(r.substr(0,m.size()));
}
} while(next_permutation(r.begin(),r.end()));
cout << se.size() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
string S;
int idx;
int N, M;
string alphas;
int curr;
struct ConsumeException{};
void consume(char c) {
if(idx >= N) throw ConsumeException();
if(S[idx] != c) throw ConsumeException();
idx ++;
}
bool try_consume(char c) {
try {
consume(c);
} catch(ConsumeException e) {
return false;
}
return true;
}
int E();
int convert(string const& b) {
int n = b.size();
int ret = 0;
for(int i=0; i<n; i++) {
ret *= 2;
assert(isdigit(b[i]));
ret += b[i] - '0';
}
return ret;
}
string B() {
string ret;
while(1) {
if(S[idx] == '0') ret += '0';
else if(S[idx] == '1') ret += '1';
else break;
idx++;
}
return ret;
}
int Nu() {
if(try_consume('0')) return 0;
consume('1');
return convert("1" + B());
}
int F() {
if(try_consume('-')) {
return -F();
}
else if(try_consume('(')) {
int r = E();
consume(')');
return r;
}
else {
return Nu();
}
}
int T() {
int num1 = F();
while(try_consume('*')) {
int num2 = F();
num1 *= num2;
}
return num1;
}
int E() {
int term1 = T();
while(1) {
bool cont = 0;
while(try_consume('+')) {
cont = 1;
int term2 = T();
term1 += term2;
}
while(try_consume('-')) {
cont = 1;
int term2 = T();
term1 -= term2;
}
if(!cont) break;
}
return term1;
}
bool Q() {
int expr1 = E();
consume('=');
int expr2 = E();
return expr1 == expr2 && idx == N;
}
int main() {
string T = "01+-*()=";
sort(T.begin(), T.end());
string RS; cin >> RS;
N = RS.size();
for(auto c: RS) if(isalpha(c)) alphas.push_back(c);
sort(alphas.begin(), alphas.end());
alphas.erase(unique(alphas.begin(), alphas.end()), alphas.end());
M = alphas.size();
if(M > T.size()) {
cout << 0 << endl;
return 0;
}
int ans = 0;
set<string> st;
do {
S = RS;
rep(i, N) {
if(isalpha(S[i])) S[i] = T[alphas.find(S[i])];
}
if(!st.count(S)) {
st.insert(S);
idx = curr = 0;
try { ans += Q(); } catch (...) {}
}
} while(next_permutation(T.begin(), T.end()));
cout << ans << endl;
return 0;
} |
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
using namespace std;
pair<int, int> isE(const std::string &s, int start, int end);
pair<int,int> isB(const std::string &s, int start) {
// cout << "isB " << s << " " << start << endl;
pair<int, int> p;
int x = 0;
if (s[start] != '0' && s[start] != '1') {
return make_pair(-1, -1);
}
if (s[start] == '0') {
return make_pair(0, start + 1);
}
while (start < s.length() && (s[start] == '0' || s[start] == '1')) {
x = x << 1;
x += s[start] - '0';
start++;
}
return make_pair(x, start);
}
pair<int, int> isF(const std::string &s, int start, int end) {
// cout << "isF " << s << " " << start << " " << end << endl;
if (start >= end) return make_pair(-1, -1);
if (s[start] == '(') {
if (s[end - 1] != ')') return make_pair(-1, -1);
pair<int, int> p = isE(s, start + 1, end - 1);
if (p.second == -1) return p;
return make_pair(p.first, p.second + 1);
}
if (s[start] == '-') {
pair<int, int> p = isF(s, start + 1, end);
// cout << "isF return from - " << p.first << ", " << p.second << endl;
if (p.second == -1) return p;
if (p.second != end) return make_pair(-1, -1);
p.first *= -1;
return p;
}
pair<int, int> p = isB(s, start);
// cout << "isF last " << s << start << " " << end << " " << p.first << "," << p.second << " " << end << endl;
if (p.second == end) return p;
// cout << "isF last " << s << start << " " << end << " " << p.first << "," << p.second << " " << end << endl;
return make_pair(-1, -1);
}
pair<int, int> isT(const std::string &s, int start, int end) {
for (int i = end - 1; i > start; --i) {
if (s[i] == '*') {
pair<int, int> p = isF(s, i+1, end);
if (p.second == -1) continue;
pair<int, int> q = isT(s, start, i);
if (q.second == -1) continue;
return make_pair(p.first * q.first, end);
}
}
pair<int, int> p = isF(s, start, end);
// cout << "last isT " << s << " " << start << " " << p.first << " " << p.second << endl;
return p;
}
pair<int, int> isE(const std::string &s, int start, int end) {
if (start >= end) return make_pair(-1, -1);
for (int i = end - 1; i > start; --i) {
if (s[i] == '+' || s[i] == '-') {
pair<int, int> p = isT(s, i + 1, end);
if (p.second == -1) continue;
pair<int, int> q = isE(s, start, i);
if (q.second == -1) continue;
if (s[i] == '+') {
return make_pair(p.first + q.first, end);
}
if (s[i] == '-') {
return make_pair(q.first - p.first, end);
}
}
}
pair<int, int> p = isT(s, start, end);
// cout << "last isE " << s << " " << start << " " << p.first << " " << p.second << endl;
return p;
}
bool isQ(const std::string &s) {
int idx = -1;
for (int i = 1; i < s.length() - 1; ++i) {
if (s[i] == '=') {
idx = i;
break;
}
}
if (idx == -1) return false;
pair<int, int> p = isE(s, 0, idx);
if (p.second == -1 || s[p.second] != '=') return false;
// cout << "isQ after p before q" << endl;
pair<int, int> q = isE(s, p.second+1, s.length());
// cout << "isQ last before " << q.first << ", " << q.first << ": " << s << endl;
if (q.second == -1) return false;
// cout << "isQ last " << p.first << ", " << q.first << ": " << s << endl;
return p.first == q.first;
}
bool check(const std::string &s) {
return isQ(s);
}
int main() {
string s;
cin >> s;
std::vector<char> ops = {'=', '+', '-', '*', '(', ')', '0', '1'};
sort(ops.begin(), ops.end());
std::set<char> chars;
for (int i = 0; i < s.length(); ++i) {
if ((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z')) {
chars.insert(s[i]);
}
}
std::vector<char> abc;
for (const char c : chars) abc.push_back(c);
if (abc.size() > ops.size()) {
cout << "0" << endl;
return 0;
}
std::map<char, char> m;
for (int i = 0; i < ops.size(); ++i) m[ops[i]] = ops[i];
std::set<string> ans;
do {
for (int i = 0; i < abc.size(); ++i) m[abc[i]] = ops[i];
string ss = s;
for (int i = 0; i < s.length(); ++i) ss[i] = m[s[i]];
if (check(ss)) {
ans.insert(ss);
}
} while (next_permutation(ops.begin(), ops.end()));
cout << ans.size() << endl;
// for (const std::string &s : ans) {
// cout << s << endl;
// }
} |
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <cstring>
#include <stack>
#include <iostream>
#include <vector>
#include <map>
#define FAIL (make_pair(0,0))
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
char a[] = "01+-*()=";
int pr[500];
char s[100];
char t[100];
int n,ans;
map<char,char> m;
bool work(stack<LL> &res,stack<char> & op){
if(res.empty())return 0;
if(res.top() == '(')return 0;
if(op.top() == '#'){
res.top() = -res.top();
op.pop();
return 1;
}
LL tem = res.top();
res.pop();
if(res.empty())return 0;
if(op.top() == '+'){
res.top() += tem;
}else if(op.top() == '-'){
res.top() -= tem;
}else{
res.top() *= tem;
}
op.pop();
return 1;
}
pair<LL, bool>get(int l,int r){
if(l >= r)return make_pair(0, 0);
if(t[l] == '+' || t[l] == '*' || t[l] == ')')return FAIL;
if(t[r - 1] == '+' || t[r - 1] == '*' || t[r - 1] == '(' || t[r - 1] == '-')return FAIL;
stack<LL> res;
stack<char> op;
for(int i = l;i < r; ++i){
//cout << l <<" "<<i<<endl;
if(isdigit(t[i])){
LL tem = 0;
int st = i;
while(i < r && isdigit(t[i])){
tem = tem * 2 + t[i] - '0';
i++;
}
if(st + 1 < i && t[st] == '0')return FAIL;
res.push(tem);
i--;
continue;
}
if(t[i] == '('){
op.push('(');
if(i > l && (isdigit(t[i - 1]) || t[i - 1] == ')'))return FAIL;
if(i < r -1 && !(isdigit(t[i + 1]) || t[i + 1] == '(' || t[i + 1] == '#'))return FAIL;
continue;
}
if(t[i] == ')'){
//cout <<l <<endl;
if(i > l && !(isdigit(t[i - 1]) || t[i - 1] == ')'))return FAIL;
if(i < r - 1 && (isdigit(t[i + 1]) || t[i + 1] == '('))return FAIL;
while(op.empty() == false && op.top() != '('){
bool flag = work(res, op);
if(flag == 0)return FAIL;
}
if(op.empty() == true)return FAIL;
op.pop();
continue;
}
while(op.empty() == false && pr[op.top()] >= pr[t[i]]){
bool flag = work(res, op);
if(flag == 0)return FAIL;
}
op.push(t[i]);
}
while(!op.empty()){
bool flag = work(res, op);
if(flag == 0)return FAIL;
}
if(res.size() == 1)return make_pair(res.top(),1);
return FAIL;
}
bool check(){
for(int i = 0;i < n; ++i){
if(isalpha(s[i])){
t[i] = m[s[i]];
}else{
t[i] = s[i];
}
}
int n = ::n;
for(int i = 0;i < n; ++i){
if(t[i] != '-')continue;
if(i && (t[i - 1] == ')' || isdigit(t[i - 1]))){
continue;
}
t[i] = '#';
}
for(int i = 1; i < n; ++i){
if(t[i - 1] == '#' && t[i] == '#'){
for(int j = i + 1; j < n; ++j){
t[j - 2] = t[j];
}
n -= 2;
i --;
}
}
if(t[0] == '=' || t[n - 1] == '=')return 0;
int equal = 0,pos = -1;
for(int i = 0;i < n; ++i){
if(t[i] == '='){
equal++;
pos = i;
}
}
if(equal != 1)return 0;
pair<LL,bool> left = get(0,pos);
if(left.second == false)return 0;
pair<LL,bool> righ = get(pos + 1,n);
if(righ.second == false)return 0;
// if(left == righ){
// for(int i = 0;i < n; ++i){
// cout << t[i];
// }
// cout << endl;
// }
return left == righ;
}
void dfs(int o){
if(o == n){
ans += check();
return;
}
if(isalpha(s[o])){
if(m.find(s[o]) != m.end()){
dfs(o + 1);
}else{
for(int i = 0;i < 8; ++i){
if(m.find(a[i]) != m.end())continue;
m[s[o]] = a[i];
m[a[i]] = s[o];
dfs(o + 1);
m.erase(s[o]);
m.erase(a[i]);
}
}
}else{
t[o] = s[o];
dfs(o + 1);
}
}
int main(){
pr['('] = -1;
pr['*'] = 1;
pr['+'] = 0;
pr['-'] = 0;
pr[')'] = -1;
pr['#'] = 3;
scanf("%s",s);
n = int(strlen(s));
dfs(0);
cout << ans << endl;
return 0;
} |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
char component_array[8] = {'0','1','+','-','*','(',')','=',};
int table[40320][8];
int num_of_type,table_index;
int calc_E(char line[32],int left,int right);
int calc_T(char line[32],int left,int right);
int calc_F(char line[32],int left,int right);
int calc_NUM(char line[32],int left,int right);
bool is_component(char ch){
for(int i = 0; i < 8; i++){
if(ch == component_array[i])return true;
}
return false;
}
void makeTable(bool used[8],int change_list[8],int index){
if(index == num_of_type){ //対応表の作成が完成した場合
for(int i = 0; i < num_of_type; i++){
table[table_index][i] = change_list[i];
}
table_index++;
return;
}
for(int i = 0; i < 8; i++){
if(used[i] == false){
bool next_used[8];
int next_change_list[8];
for(int k = 0; k < 8; k++)next_used[k] = used[k];
for(int k = 0; k < index; k++)next_change_list[k] = change_list[k];
next_used[i] = true;
next_change_list[index] = i;
makeTable(next_used,next_change_list,index+1);
}
}
}
bool is_OK(char work[32]){
int length;
for(length = 0; work[length] != '\0'; length++);
int equal_count = 0;
for(int i = 0; work[i] != '\0'; i++){
if(work[i] == '=')equal_count++;
}
if(equal_count != 1)return false; //'='の数が1でないなら不可
int eq_pos;
for(int i = 0; i < length; i++){
if(work[i] == '='){
eq_pos = i;
break;
}
}
if(eq_pos == 0 || eq_pos == length-1)return false; //'='の場所が左端、または右端なら不可
//異種カッコが連続していないか調べる
for(int i = 0; i < length; i++){
if(work[i] == '(' && work[i+1] == ')')return false;
if(work[i] == ')' && work[i+1] == '(')return false;
}
//カッコの対応が取れているかチェック(左半分)
stack<int> S;
for(int i = 0; i < eq_pos; i++){
if(work[i] == '(')S.push(i);
else if(work[i] == ')'){
if(S.size() == 0)return false;
else{
S.pop();
}
}
}
if(S.size() > 0)return false;
//カッコの対応が取れているかチェック(右半分)
for(int i = eq_pos+1; i < length; i++){
if(work[i] == '(')S.push(i);
else if(work[i] == ')'){
if(S.size() == 0)return false;
else{
S.pop();
}
}
}
if(S.size() > 0)return false;
//左端を調べる
if(work[0] == '+' || work[0] == '*')return false;
if(work[eq_pos+1] == '+' || work[eq_pos+1] == '*')return false;
//数字と開きカッコ、開きカッコと(*or+)が連結していないか調べる
for(int i = 0; i < length; i++){
if((work[i] == '0' || work[i] == '1') && work[i+1] == '(')return false;
if((work[i] == '(') && (work[i+1] == '*' || work[i+1] == '+'))return false;
}
//バイナリが複数桁の場合、1スタートか調べる
for(int i = 0; work[i] != '\0';){
if(work[i] != '0' && work[i] != '1')i++;
else{
if(work[i] == '1'){
while(work[i] == '1' || work[i] == '0')i++;
}else{ //左端の0
if(work[i+1] == '1' || work[i+1] == '0')return false;
i++;
}
}
}
//opの連結を調べる
for(int i = 0; work[i] != '\0'; i++){
if((work[i] == '+' || work[i] == '*') &&
(work[i+1] == '+' || work[i+1] == '*' || work[i+1] == '='|| work[i+1] == ')' || work[i+1] == '\0'))return false;
if((work[i] == '-') &&
(work[i+1] == '+' || work[i+1] == '*' || work[i+1] == '=' || work[i+1] == ')' || work[i+1] == '\0'))return false;
}
return true;
}
int calc_E(char line[32],int left,int right){
/*printf("E\n");
for(int i = left; i <= right; i++){
printf("%c",line[i]);
}
printf("\n");*/
int depth = 0;
queue<int> Q;
//深さ0の、プラスまたは-を探す
for(int i = left; i <= right; ){
if(line[i] == '(')depth++;
else if(line[i] == ')')depth--;
if(depth != 0){
i++;
}else if(line[i] != '+' && line[i] != '-'){
i++;
}else{
if(line[i] == '+'){
Q.push(i);
i++;
}else{ //line[i] == '-'
if((i != left) && (line[i-1] == '0' || line[i-1] == '1' || line[i-1] == ')')){ //-は、depthが0でもnegの場合あり
Q.push(i);
}
while(i <=right && line[i] == '-')i++; //negの-が続いている場合があるので、読み飛ばす
}
}
}
if(Q.empty()){ //深さ0の+-がない
return calc_T(line,left,right);
}
int tmp = calc_E(line,left,Q.front()-1),tmp_right;
if(tmp == BIG_NUM)return BIG_NUM;
while(!Q.empty()){
int loc = Q.front();
Q.pop();
if(Q.empty()){
tmp_right = calc_T(line,loc+1,right);
}else{
tmp_right = calc_T(line,loc+1,Q.front()-1);
}
if(tmp_right == BIG_NUM){
return BIG_NUM;
}
if(line[loc] == '+'){
tmp += tmp_right;
}else{
tmp -= tmp_right;
}
}
return tmp;
}
int calc_T(char line[32],int left,int right){
int depth = 0;
queue<int> Q;
//深さ0の、*を探す
for(int i = left; i <= right; ){
if(line[i] == '(')depth++;
else if(line[i] == ')')depth--;
if(depth != 0){
i++;
}else if(line[i] != '*'){
i++;
}else{
Q.push(i);
i++;
}
}
if(Q.empty()){ //深さ0の*がない
return calc_F(line,left,right);
}
int tmp = calc_T(line,left,Q.front()-1),tmp_right;
if(tmp == BIG_NUM)return BIG_NUM;
while(!Q.empty()){
int loc = Q.front();
Q.pop();
if(Q.empty()){
tmp_right = calc_F(line,loc+1,right);
}else{
tmp_right = calc_F(line,loc+1,Q.front()-1);
}
if(tmp_right == BIG_NUM){
return BIG_NUM;
}
tmp *= tmp_right;
}
return tmp;
}
int calc_F(char line[32],int left,int right){
if(line[left] == '1' || line[left] == '0'){
return calc_NUM(line,left,right);
}else if(line[left] == '-'){
return -1*calc_F(line,left+1,right);
}else if(line[left] == '('){
/*printf("Minhi!\n");
for(int i = left; i <= right; i++){
printf("%c",line[i]);
}
printf("\n");*/
int depth = 0;
int close_pos = BIG_NUM;
for(int i = left; i <= right; i++){
if(line[i] == '(')depth++;
else if(line[i] == ')'){
depth--;
if(depth == 0){
close_pos = i;
break;
}
}
}
if(close_pos == BIG_NUM || close_pos != right)return BIG_NUM;
return calc_E(line,left+1,close_pos-1);
}else{
return BIG_NUM;
}
}
int calc_NUM(char line[32],int left,int right){
//left～rightに0か1以外の文字が入っていたら不適
for(int i = left; i <= right; i++){
if(line[i] != '0' && line[i] != '1')return BIG_NUM;
}
int ret = 0;
for(int i = left; i <= right; i++){
ret = 2*ret+line[i]-'0';
}
return ret;
}
int main(){
char buf[32];
scanf("%s",buf);
int check_table[128];
for(int i = 0; i < 128; i++)check_table[i] = 0;
vector<int> CHAR_LIST,REPLACE_LOC[128];
num_of_type = 0; //置き換える文字の種類数
for(int i = 0; buf[i] != '\0'; i++){
if(!is_component(buf[i])){ //置き換える必要のある文字である場合
REPLACE_LOC[buf[i]].push_back(i); //buf[i]が何文字目にあるかのリスト
if(check_table[buf[i]] == 0){ //初登場
num_of_type++;
check_table[buf[i]]++;
CHAR_LIST.push_back(buf[i]); //置き換える文字のリストに追加
}
}
}
if(num_of_type > 8){ //構成要素は8種類しかないので、9種類以上置き換え文字があったら答えは0
printf("0\n");
return 0;
}
char work[32],left_table[32],right_table[32];
int eq_pos,left_result,right_result,right_length,ans = 0;
if(num_of_type == 0){ //置き換えるべき文字が無い場合
if(!is_OK(buf)){ //入力の文字列が文法的に間違っている場合
printf("0\n");
return 0;
}
//左辺と右辺に数式を分解する
for(int i = 0; buf[i] != '\0'; i++){
if(buf[i] == '='){
eq_pos = i;
break;
}
left_table[i] = buf[i];
left_table[i+1] = '\0';
}
right_length = 0;
for(int i = 0; buf[eq_pos+1+i] != '\0'; i++){
right_table[i] = buf[eq_pos+1+i];
right_length++;
right_table[i+1] = '\0';
}
left_result = calc_E(left_table,0,eq_pos-1);
if(abs(left_result) == BIG_NUM){
printf("0\n");
return 0;
}
right_result = calc_E(right_table,0,right_length-1);
if(left_result == right_result){
printf("1\n");
}else{
printf("0\n");
}
return 0;
}
bool first_used[8];
for(int i = 0; i < 8; i++)first_used[i] = false;
int first_change_list[8];
table_index = 0;
makeTable(first_used,first_change_list,0); //アルファベットと、文字の変換表を作る
for(int i = 0; i < table_index; i++){
for(int k = 0; buf[k] != '\0'; k++){
work[k] = buf[k];
work[k+1] = '\0';
}
//文字を置き換える
for(int k = 0; k < num_of_type; k++){
int word = CHAR_LIST[k];
for(int a = 0; a < REPLACE_LOC[word].size(); a++){
int loc = REPLACE_LOC[word][a];
work[loc] = component_array[table[i][k]];
}
}
//文法的に適切かどうかざっと確かめる(OKでも不適な場合が多数ある)
if(!is_OK(work))continue;
//左辺と右辺に数式を分解する
for(int i = 0; work[i] != '\0'; i++){
if(work[i] == '='){
eq_pos = i;
break;
}
left_table[i] = work[i];
left_table[i+1] = '\0';
}
right_length = 0;
for(int i = 0; work[eq_pos+1+i] != '\0'; i++){
right_table[i] = work[eq_pos+1+i];
right_length++;
right_table[i+1] = '\0';
}
/* printf("left:%s\n",left_table);
printf("right:%s\n",right_table);*/
left_result = calc_E(left_table,0,eq_pos-1);
//printf("left_res:%d\n",left_result);
if(abs(left_result) == BIG_NUM)continue;
right_result = calc_E(right_table,0,right_length-1);
//printf("right_res:%d\n\n",right_result);
if(abs(right_result) == BIG_NUM)continue;
if(left_result == right_result){
/*printf("left:%s\n",left_table);
printf("right:%s\n",right_table);*/
ans++;
}
}
printf("%d\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
string S;
int idx;
int N, M;
string alphas;
int curr;
bool consume(char c) {
if(idx >= N) return false;
if(S[idx] != c) return false;
idx ++;
return true;
}
int E();
int convert(string const& b) {
int n = b.size();
int ret = 0;
for(int i=0; i<n; i++) {
ret *= 2;
assert(isdigit(b[i]));
ret += b[i] - '0';
}
return ret;
}
string B() {
string ret;
while(1) {
if(S[idx] == '0') ret += '0';
else if(S[idx] == '1') ret += '1';
else break;
idx++;
}
return ret;
}
int Nu() {
if(consume('0')) {
return 0;
}
else if(consume('1')) {
return convert("1" + B());
}
else {
return -inf;
}
}
int F() {
if(consume('-')) {
int r = F();
if(r == -inf) return -inf;
return -r;
}
else if(consume('(')) {
int r = E();
if(r == -inf) return -inf;
if(!consume(')')) return -inf;
return r;
}
else {
return Nu();
}
}
int T() {
int num1 = F();
if(num1 == -inf) return -inf;
while(consume('*')) {
int num2 = F();
if(num2 == -inf) return -inf;
num1 *= num2;
}
return num1;
}
int E() {
int term1 = T();
if(term1 == -inf) return -inf;
while(1) {
bool cont = 0;
while(consume('+')) {
cont = 1;
int term2 = T();
if(term2 == -inf) return -inf;
term1 += term2;
}
while(consume('-')) {
cont = 1;
int term2 = T();
if(term2 == -inf) return -inf;
term1 -= term2;
}
if(!cont) break;
}
return term1;
}
bool Q() {
if(idx == N) return curr == 0;
int expr1 = E();
if(expr1 == -inf) return false;
if(!consume('=')) return false;
int expr2 = E();
if(expr2 == -inf) return false;
if(expr1 != expr2) return false;
return idx == N;
}
int main() {
string T = "01+-*()=";
sort(T.begin(), T.end());
int Tsize = T.size();
string RS; cin >> RS;
N = RS.size();
for(auto c: RS) if(isalpha(c)) alphas.push_back(c);
sort(alphas.begin(), alphas.end());
alphas.erase(unique(alphas.begin(), alphas.end()), alphas.end());
M = alphas.size();
if(M > T.size()) {
cout << 0 << endl;
exit(0);
}
int ans = 0;
set<string> st;
do {
S = RS;
rep(i, N)
if(isalpha(S[i])) S[i] = T[alphas.find(S[i])];
if(!st.count(S)) {
st.insert(S);
idx = curr = 0;
ans += Q();
}
} while(next_permutation(T.begin(), T.end()));
cout << ans << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
const int INF=1001001001001001001ll;
string S;
int ei(string::iterator &it,int r){
if(r==0){
vint lis;
while(it!=S.end()){
int x=ei(it,1);
if(*it!='='||x==INF)return INF;
lis.pb(x);
it++;
}
if(lis.size()!=2||lis[0]!=lis[1])return INF;
return 114514;
}
if(r==1){
int ret=ei(it,2);
if(ret==INF)return INF;
while(true){
if(*it=='+'){
it++;
int x=ei(it,2);
if(x==INF)return INF;
ret+=x;
}
else if(*it=='-'){
it++;
int x=ei(it,2);
if(x==INF)return INF;
ret-=x;
}
else break;
}
return ret;
}
if(r==2){
int ret=ei(it,3);
if(ret==INF)return INF;
while(true){
if(*it=='*'){
it++;
int x=ei(it,3);
if(x==INF)return INF;
ret*=x;
}
else break;
}
return ret;
}
if(r==3){
if(*it=='-'){
it++;
int x=ei(it,3);
if(x==INF)return INF;
return -x;
}
if(*it=='('){
it++;
int x=ei(it,1);
if(*it!=')')return INF;
it++;
if(x==INF)return INF;
return x;
}
return ei(it,4);
}
if(r==4){
bool f=*it=='0';
if(!isdigit(*it))return INF;
int ret=0;
int cnt=0;
while(isdigit(*it)){
ret=ret*2+*it-'0';
it++;
cnt++;
}
if(f&&cnt!=1)return INF;
return ret;
}
}
signed main(){
string s;cin>>s;
vector<char>v;
rep(i,s.size())if(isalpha(s[i]))v.pb(s[i]);
sort(all(v));v.erase(unique(all(v)),v.end());
if(v.size()>8){
cout<<0<<endl;
return 0;
}
string x="+-*()=01";
sort(all(x));
int ans=0;
set<string>st;
do{
S=s;
rep(i,S.size()){
if(isalpha(S[i])){
int k=lower_bound(all(v),S[i])-v.begin();
S[i]=x[k];
}
}
S+="=";
auto it=S.begin();
if(ei(it,0)!=INF){
ans++;
}
}while(next_permutation(all(x)));
rep(i,(int)x.size()-(int)v.size())ans/=i+1;
cout<<ans<<endl;
return 0;
} |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int parse_formula(int &p, string &s);
int parse_term(int &p, string &s);
int parse_factor(int &p, string &s);
int parse_number(int &p, string &s);
int parse_formula(int &p, string &s){
int n = s.length();
if(p>=n or s[p]==')'){
throw exception();
}
int res = parse_term(p, s);
while(p<n and (s[p]=='+' or s[p]=='-')){
int sign = (s[p]=='+')? 1: -1;
res += sign*parse_term(++p, s);
}
if(p>=n or s[p]!=')'){
throw exception();
}
p++;
return res;
}
int parse_term(int &p, string &s){
int n = s.length();
int res = 1;
while(1){
res *= parse_factor(p, s);
if(p>=n or s[p]==')' or s[p]!='*') break;
p++;
}
return res;
}
int parse_factor(int &p, string &s){
int n = s.length();
int sign = 1;
while(p<n and s[p]=='-'){
sign *= -1;
p++;
}
if(p>=n or !(s[p]=='(' or s[p]=='0' or s[p]=='1')){
throw exception();
}
if(s[p]=='('){
return sign * parse_formula(++p, s);
}else{
return sign * parse_number(p, s);
}
}
int parse_number(int &p, string &s){
int n = s.length();
int res = 0;
if(p>=n or !(s[p]=='0' or s[p]=='1')){
throw exception();
}
bool leading_zero = s[p]=='0';
int firstp = p;
while(p<n and (s[p]=='0' or s[p]=='1')){
res *= 2;
res += s[p]-'0';
p++;
}
if(leading_zero and p-firstp > 1){
throw exception();
}
return res;
}
const string alphabet = "01+-*()=";
int main(){
string s;
cin >> s;
vector<char> assign;
for(char c: s){
if(('a'<=c and c<='z') or ('A'<=c and c<='Z')){
assign.push_back(c);
}
}
sort(assign.begin(), assign.end());
assign.erase(unique(assign.begin(), assign.end()), assign.end());
while(assign.size() < alphabet.length()){
assign.push_back('~');
}
int ans = 0;
do{
string t = s;
for(int i=0; i<8; i++){
for(int j=0; j<(int)t.length(); j++){
if(t[j] == assign[i]){
t[j] = alphabet[i];
}
}
}
int poseq = -1;
for(int i=0; i<(int)t.length(); i++){
if(t[i] == '='){
if(poseq == -1) poseq = i;
else if(poseq > 0) poseq = -2;
}
}
if(poseq < 0) continue;
t[poseq] = ')';
t.push_back(')');
try{
int p = 0;
int ret1 = parse_formula(p, t);
if(p != poseq+1) continue;
int ret2 = parse_formula(p, t);
if(p != (int)t.length()) continue;
if(ret1 == ret2) ans++;
}catch(exception){
continue;
}
}while(next_permutation(assign.begin(), assign.end()));
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<vector>
#include<sstream>
#include<deque>
#include<algorithm>
#include<map>
#include<set>
#include<cstdlib>
#include<climits>
#include<cassert>
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define all(x) x.begin(),x.end()
using namespace std;
typedef long long ll;
const ll LLINF = LLONG_MAX;
const string opr = "01+-*=()";
string context;
int n;
ll parse_E(int&,string&);
ll parse_F(int &p,string &s) {
if( p >= (int)s.size() ) throw "fail";
if( s[p] == '+' ) throw "fail";
if( s[p] == '-' ) {
++p;
ll v;
try { v = parse_F(p,s); } catch(...) { throw "fail"; }
return v * -1LL;
}
if( s[p] == '(' ) {
++p;
ll v;
try { v = parse_E(p,s); } catch(...) { throw "fail"; }
if( p >= (int)s.size() ) throw "fail";
if( s[p] != ')' ) throw "fail";
++p;
if( p < (int)s.size() && ( s[p] == '0' || s[p] == '1' ) ) throw "fail";
return v;
}
int cnt = 0;
ll v = 0;
bool first_zero = ( s[p] == '0' );
while( p < (int)s.size() && ( s[p] == '0' || s[p] == '1' ) ) {
v <<= 1;
v += (ll)( s[p] - '0' );
++p;
++cnt;
}
if( first_zero && cnt != 1 ) throw "fail";
if( cnt == 0 ) throw "fail";
if( p < (int)s.size() && s[p] == '(' ) throw "fail";
return v;
}
ll parse_T(int &p,string &s) {
ll v;
try { v = parse_F(p,s); } catch(...) { throw "fail"; }
while( p < (int)s.size() && s[p] == '*' ) {
++p;
ll tmp;
try { tmp = parse_T(p,s); } catch(...) { throw "fail"; }
v *= tmp;
}
return v;
}
ll parse_E(int &p,string &s) {
ll v;
try { v = parse_T(p,s); } catch(...) { throw "fail"; }
while( p < (int)s.size() && ( s[p] == '+' || s[p] == '-' ) ) {
char op = s[p];
++p;
ll tmp;
try { tmp = parse_T(p,s); } catch(...) { throw "fail"; }
if( op == '+' ) v += tmp;
if( op == '-' ) v -= tmp;
}
return v;
}
bool pari_check(string &s) {
int cnt = 0;
rep(i,(int)s.size()) {
if( s[i] == '(' ) ++cnt;
if( s[i] == ')' ) --cnt;
if( cnt < 0 ) return false;
}
return cnt == 0;
}
bool check() {
string s,t;
{
string tmp;
tmp = context;
rep(i,n) if( context[i] == '=' ) tmp[i] = ' ';
vector<string> vec;
stringstream ss;
ss << tmp;
while( ss >> s ) vec.push_back(s);
if( vec.size() != 2 ) return false;
s = vec[0];
t = vec[1];
}
if( !pari_check(s) || !pari_check(t) ) return false;
int p = 0;
ll sv,tv;
try {
sv = parse_E(p,s);
p = 0;
tv = parse_E(p,t);
} catch(...) {
return false;
}
if( sv == LLINF || tv == LLINF) return false;
return sv == tv;
}
int dfs(int ptr,int used,vector<char> &already) {
if( n <= ptr ) return check();
if( !isalpha(context[ptr]) ) return dfs(ptr+1,used,already);
int sum = 0;
int v = context[ptr] - 'a';
if( already[v] != '$' ) {
if( already[v] == '=' ) return 0;
char tmp = context[ptr];
context[ptr] = already[v];
sum += dfs(ptr+1,used,already);
context[ptr] = tmp;
return sum;
}
rep(i,(int)opr.size()) {
if( ( used >> i ) & 1 ) continue;
char tmp = context[ptr];
context[ptr] = opr[i];
already[v] = opr[i];
sum += dfs(ptr+1,used|(1<<i),already);
already[v] = '$';
context[ptr] = tmp;
}
return sum;
}
bool normalize() {
vector<char> vec;
rep(i,(int)context.size()) if( isalpha(context[i]) ) vec.push_back(context[i]);
sort(all(vec));
vec.erase(unique(all(vec)),vec.end());
rep(i,(int)context.size()) if( isalpha(context[i]) ) {
int pos = lower_bound(all(vec),context[i]) - vec.begin();
context[i] = (char)('a'+pos);
}
return (int)vec.size() <= 8;
}
void compute() {
if( !normalize() ) { puts("0"); return; }
n = (int)context.size();
int used = 0;
rep(i,n) if( context[i] == '=' ) { used = (1<<5); break; }
vector<char> vec(8,'$');
cout << dfs(0,used,vec) << endl;
}
int main() {
if( 0 ) {
string s;
cin >> s;
int p = 0;
cout << parse_E(p,s) << endl;
return 0;
}
cin >> context;
compute();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
bool flg;
int expr(string s,int& p);
int term(string s,int& p);
int factor(string s,int& p);
int number(string s,int& p);
int expr(string s,int& p){
int res=term(s,p);
while(p<(int)s.size()){
if(flg) return 0;
if(s[p]=='+'){
p++;
res+=term(s,p);
continue;
}
if(s[p]=='-'){
p++;
res-=term(s,p);
continue;
}
break;
}
return res;
}
int term(string s,int& p){
int res=factor(s,p);
while(p<(int)s.size()){
if(flg) return 0;
if(s[p]=='*'){
p++;
res*=factor(s,p);
continue;
}
break;
}
return res;
}
int factor(string s,int& p){
int res;
if(s[p]=='-'){
p++;
res=-factor(s,p);
}else if(s[p]=='('){
p++;
res=expr(s,p);
if(p>=(int)s.size()||s[p]!=')'){
flg=1;
return 0;
}
p++;
}else if(isdigit(s[p])){
res=number(s,p);
}else{
flg=1;
return 0;
}
return res;
}
int number(string s,int& p){
if(s[p]=='0'){
if(p+1<s.size()&&isdigit(s[p+1])){
flg=1;
return 0;
}
p++;
return 0;
}
int res=0;
while(p<(int)s.size()&&isdigit(s[p])) res=res*2+s[p++]-'0';
return res;
}
bool check(string s){
if(s.size()==0) return 0;
int op=0;
for(int i=0;i<(int)s.size();i++){
if(s[i]=='(') op++;
if(s[i]==')') op--;
if(op<0) return 0;
}
if(op) return 0;
return 1;
}
//set<string> ss;
int Q(string s){
if(count(s.begin(),s.end(),'=')!=1) return 0;
int k=s.find('=');
string a=s.substr(0,k);
string b=s.substr(k+1,s.size()-(k+1));
if(!check(a)) return 0;
if(!check(b)) return 0;
//cout<<s<<endl;
//cout<<a<<" "<<b<<endl;
flg=0;
int p=0;
int x=expr(a,p);
//cout<<flg<<" "<<p<<" "<<x<<endl;
if(flg||p!=(int)a.size()) return 0;
p=0;
int y=expr(b,p);
//cout<<flg<<" "<<p<<" "<<y<<endl;
if(flg||p!=(int)b.size()) return 0;
//cout<<a<<" "<<b<<endl;
//cout<<x<<":"<<y<<endl;
return x==y;
}
int ans=0;
string l="01+-*()=";
void dfs(string s,int b){
bool f=1;
for(int i=0;i<(int)s.size();i++){
if(!isalpha(s[i])) continue;
f=0;
char c=s[i];
for(int j=0;j<(int)l.size();j++){
if((b>>j)&1) continue;
string t=s;
for(int k=0;k<(int)s.size();k++){
if(t[k]==c) t[k]=l[j];
}
dfs(t,b+(1<<j));
}
break;
}
if(f) ans+=Q(s);
}
signed main(){
string s;
cin>>s;
dfs(s,0);
cout<<ans<<endl;
return 0;
} |
/* -*- coding: utf-8 -*-
*
* 1371.cc: Infallibly Crack Perplexing Cryptarithm
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
/* constant */
const int CN = 8;
const char cs[] = "01+-*()=";
const int MAX_PN = 40320; // = 8!
const long long LINF = 1LL << 62;
/* typedef */
typedef long long ll;
/* global variables */
char s[64], t[64];
int vmap[128], cns[CN], pss[MAX_PN][CN], ps[CN], pn = 0;
bool used[CN];
/* subroutines */
void rec_perm(int u, int vn) {
if (u >= vn) {
memcpy(pss[pn++], ps, sizeof(pss[0]));
return;
}
for (int c = 0; c < CN; c++)
if (! used[c]) {
used[c] = true;
ps[u] = c;
rec_perm(u + 1, vn);
used[c] = false;
}
}
ll expr(char *(&cpt));
ll num(char *(&cpt)) {
bool swz = (*cpt == '0');
ll v0 = 0;
int l = 0;
while (*cpt == '0' || *cpt == '1')
v0 = (v0 << 1) | (*(cpt++) - '0'), l++;
if (swz && l > 1) return LINF;
return v0;
}
ll factor(char *(&cpt)) {
if (*cpt == '0' || *cpt == '1') return num(cpt);
if (*cpt == '-') {
cpt++; // '-;
ll v0 = factor(cpt);
if (v0 >= LINF) return LINF;
return -v0;
}
if (*cpt == '(') {
cpt++; // '('
ll v0 = expr(cpt);
if (v0 >= LINF || *cpt != ')') return LINF;
cpt++; // ')'
return v0;
}
return LINF;
}
ll term(char *(&cpt)) {
ll v0 = factor(cpt);
if (v0 >= LINF) return LINF;
while (*cpt == '*') {
cpt++; // '*'
ll v1 = factor(cpt);
if (v1 >= LINF) return LINF;
v0 *= v1;
}
return v0;
}
ll expr(char *(&cpt)) {
ll v0 = term(cpt);
if (v0 >= LINF) return LINF;
while (*cpt == '+' || *cpt == '-') {
char op = *(cpt++); // '+' || '-'
ll v1 = term(cpt);
if (v1 >= LINF) return LINF;
if (op == '+') v0 += v1;
else v0 -= v1;
}
return v0;
}
/* main */
int main() {
scanf("%s", s);
memset(vmap, -1, sizeof(vmap));
int vn = 0;
for (int i = 0; s[i]; i++) {
if ((s[i] >= 'A' && s[i] <= 'Z') || (s[i] >= 'a' && s[i] <= 'z')) {
int vid = vmap[s[i]];
if (vid < 0) vid = vmap[s[i]] = vn++;
s[i] = vid + 1;
cns[vid]++;
}
//if (s[i] < vn) printf("[%d]", s[i]);
//else putchar(s[i]);
}
//putchar('\n');
if (vn > CN) {
puts("0");
return 0;
}
rec_perm(0, vn);
//printf("pn=%d\n", pn);
int cnt = 0;
for (int pi = 0; pi < pn; pi++) {
int eql = 0, obr = 0, cbr = 0;
for (int i = 0; s[i]; i++) {
if (s[i] <= vn) t[i] = cs[pss[pi][s[i] - 1]];
else t[i] = s[i];
switch (t[i]) {
case '=': eql++; break;
case '(': obr++; break;
case ')': cbr++; break;
}
}
if (eql != 1 || obr != cbr) continue;
//puts(t);
char *cpt = t;
ll v0 = expr(cpt);
if (v0 < LINF && *cpt == '=') {
cpt++; // '='
ll v1 = expr(cpt);
if (v1 < LINF && v0 == v1 && *cpt == '\0') {
cnt++;
//puts(t);
}
}
}
printf("%d\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string temp = "01+-*()=";
int A(string&, int&);
int B(string&, int&);
int C(string&, int&);
int C(string& S, int& idx)
{
int ret = 0;
if(isdigit(S[idx])) {
if(isdigit(S[idx + 1]) && S[idx] == '0') throw (0);
while(isdigit(S[idx])) ret = ret * 2 + S[idx++] - '0';
} else if(S[idx] == '(') {
ret = A(S, ++idx);
if(S[idx] != ')') throw (0);
++idx;
} else if(S[idx] == '-') {
ret = -C(S, ++idx);
} else {
throw (0);
}
return (ret);
}
int B(string& S, int& idx)
{
int ret = C(S, idx);
while(S[idx] == '*') {
ret *= C(S, ++idx);
}
return (ret);
}
int A(string& S, int& idx)
{
int ret = B(S, idx);
while(S[idx] == '+' || S[idx] == '-') {
if(S[idx] == '+') ret += B(S, ++idx);
else ret -= B(S, ++idx);
}
return (ret);
}
int main()
{
string S;
int conv[32];
memset(conv, -1, sizeof(conv));
cin >> S;
vector< char > num;
for(char& c : S) {
if(isalpha(c)) num.push_back(c);
}
sort(begin(num), end(num));
num.erase(unique(begin(num), end(num)), end(num));
for(int i = 0; i < S.size(); i++) {
if(isalpha(S[i])) conv[i] = lower_bound(begin(num), end(num), S[i]) - begin(num);
}
if(num.size() > temp.size()) {
cout << 0 << endl;
return (0);
}
sort(begin(temp), end(temp));
vector< string > ss;
do {
string T = S;
for(int i = 0; i < S.size(); i++) {
if(~conv[i]) T[i] = temp[conv[i]];
}
if(count(begin(T), end(T), '=') == 1 && T.front() != '=' && T.back() != '=') {
ss.push_back(T);
}
} while(next_permutation(begin(temp), end(temp)));
sort(begin(ss), end(ss));
ss.erase(unique(begin(ss), end(ss)), end(ss));
int ret = 0;
for(string& al : ss) {
string L = "", R = "";
bool which = false;
for(int i = 0; i < al.size(); i++) {
if(al[i] == '=') {
which = true;
continue;
}
(which ? R : L) += al[i];
}
R += "$";
L += "$";
int idx;
try {
int ll = A(L, idx = 0);
if(idx + 1 != L.size()) continue;
int rr = A(R, idx = 0);
if(idx + 1 != R.size()) continue;
ret += ll == rr;
} catch(int e) {}
}
cout << ret << endl;
} |
#include <string>
#include <vector>
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<stack>
#include<queue>
#include<cmath>
#include<algorithm>
#include<functional>
#include<list>
#include<deque>
#include<bitset>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<cstring>
#include<sstream>
#include<complex>
#include<iomanip>
#include<numeric>
#include<cassert>
#define X first
#define Y second
#define pb push_back
#define rep(X,Y) for (int (X) = 0;(X) < (Y);++(X))
#define reps(X,S,Y) for (int (X) = S;(X) < (Y);++(X))
#define rrep(X,Y) for (int (X) = (Y)-1;(X) >=0;--(X))
#define rreps(X,S,Y) for (int (X) = (Y)-1;(X) >= (S);--(X))
#define repe(X,Y) for ((X) = 0;(X) < (Y);++(X))
#define peat(X,Y) for (;(X) < (Y);++(X))
#define all(X) (X).begin(),(X).end()
#define rall(X) (X).rbegin(),(X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define Endl endl
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
template<class T> using vv=vector<vector<T>>;
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"{"; rep(i,t.size()) {os<<t[i]<<",";} os<<"}"<<endl; return os;}
template<class T,size_t n> ostream& operator<<(ostream &os, const array<T,n> &t) {
os<<"{"; rep(i,n) {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<<")";}
template<class S, class T,class U> ostream& operator<<(ostream &os, const tuple<S,T,U> &t) { return os<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<")";}
template<class S, class T,class U,class V> ostream& operator<<(ostream &os, const tuple<S,T,U,V> &t) { return os<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<","<<get<3>(t)<<")";}
template<class S, class T,class U,class V,class W> ostream& operator<<(ostream &os, const tuple<S,T,U,V,W> &t) { return os<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<","<<get<3>(t)<<","<<get<4>(t)<<")";}
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
//#undef NUIP
#ifdef NUIP
#define out(args...){vector<string> a_r_g_s=s_p_l_i_t(#args, ','); e_r_r(a_r_g_s.begin(), args); }
vector<string> s_p_l_i_t(const string &s, char c){vector<string> v;int d=0,f=0;string t;for(char c:s){if(!d&&c==',')v.pb(t),t="";else t+=c;if(c=='\"'||c=='\'')f^=1;if(!f&&c=='(')++d;if(!f&&c==')')--d;}v.pb(t);return move(v);}
void e_r_r(vector<string>::iterator it) {}
template<typename T, typename... Args> void e_r_r(vector<string>::iterator it, T a, Args... args){ if(*it==" 1"||*it=="1") cerr<<endl; else cerr << it -> substr((*it)[0] == ' ', it -> length()) << " = " << a << ", "; e_r_r(++it, args...);}
#else
#define out
#endif
#ifdef __cpp_init_captures
template<typename T>vector<T> table(int n, T v){ return vector<T>(n, v);}
template <class... Args> auto table(int n, Args... args){auto val = table(args...); return vector<decltype(val)>(n, move(val));}
#endif
const ll MOD=1e9+7;
const ll INF=3e9;
ll eval(string s){
ll ok=1;
int n=s.size();
int i=0;
function<ll()> E,T,F,N;
E=[&](){
if(i==n) return ok=0;
ll re=0;
ll sgn=1,tmp;
while(1){
re+=sgn*T();
if(i<n){
if(s[i]=='+'){
sgn=1;
}else if(s[i]=='-'){
sgn=-1;
}else{
break;
}
++i;
}else break;
}
return re;
};
T=[&](){
if(i==n) return ok=0;
ll re=1,tmp;
while(1){
re*=F();
if(i==n || s[i]!='*') break;
++i;
}
return re;
};
F=[&](){
if(i==n) return ok=0;
if(s[i]=='('){
++i;
ll tmp=E();
if(s[i]!=')') return ok=0;
++i;
return tmp;
}else if(s[i]=='-'){
++i;
return -F();
}else{
if(s[i]=='0'){
if(i+1<n && isdigit(s[i+1])) return ok=0;
}else if(s[i]!='1') ok=0;
ll re=0;
while(i<n && isdigit(s[i])){
re*=2;
if(s[i]=='1') ++re;
++i;
}
return re;
}
};
ll re=E();
// out(s,re,1);
if(ok && i==n) return re;
else return INF;
}
int main(){
// out(eval("1"),1);
// out(eval("1+1"),1);
// out(eval("1+1101"),1);
// out(eval("10*1+1101"),1);
// out(eval("-0"),eval("0"),1);
// out(eval("0*"),1);
// return 0;
ios_base::sync_with_stdio(false);
cout<<fixed<<setprecision(0);
// cout<<INF*INF<<endl;
string s;
cin>>s;
string opes="01+-*()=";
string cs;
for(char c:s)if(isalpha(c)) cs+=c;
sort(all(cs)); UNIQUE(cs);
cs.resize(opes.size(),'.');
sort(all(cs));
int re=0;
do{
string str=s;
rep(i,opes.size())for(char &c:str)if(c==cs[i]) c=opes[i];
int cnt=0,pos;
rep(i,str.size())if(str[i]=='=') ++cnt, pos=i;
if(cnt!=1 || str[0]=='=' || str.back()=='=') continue;
string A=str.substr(0,pos);
string B=str.substr(pos+1);
ll a=eval(A);
ll b=eval(B);
if(a!=INF && b!=INF && a==b) ++re;
if(a!=INF && b!=INF && a==b) out(A,B,a,b,cs,opes,1);
}while(next_permutation(all(cs)));
cout<<re<<endl;
return 0;
}
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<utility>
#include<stack>
#include<bitset>
#include<map>
#include<numeric>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define stop char nyaa;cin>>nyaa;
const ll mod = 1000000007;
const long double eps = 1e-8;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef long double ld;
bool isnum(char t) {
return '0' <= t && t <= '9';
}
bool isord(char t) {
return t == '+' || t == '-' || t == '*';
}
int trans(char t) {
if ('a' <= t && t <= 'z')return t - 'a';
if ('A' <= t && t <= 'Z')return 26 + (t - 'A');
return -1;
}
const string str = "01-+*()";
int n;
ll trans_num(string s) {
int len = s.length();
ll ret = 0;
rep(i, len) {
if (s[len - i - 1] == '1')ret += (ll)1 << i;
}
return ret;
}
bool ok;
ll expr(string&s, int& i);
ll term(string&s, int& i);
ll factor(string&s, int& i);
ll number(string&s, int& i);
ll expr(string& s, int& i) {
ll val = term(s, i);
while (s[i] == '+' || s[i] == '-') {
char op = s[i]; i++;
ll val2 = term(s, i);
if (op == '+')val += val2;
else val -= val2;
}
return val;
}
ll term(string& s, int& i) {
ll val = factor(s, i);
while (s[i] == '*') {
i++;
ll val2 = factor(s, i);
val *= val2;
}
return val;
}
ll factor(string& s, int& i) {
if (isnum(s[i]))return number(s, i);
if (i<s.length()&&s[i] == '-') {
i++;
ll ret = factor(s, i);
return -ret;
}
if (i==s.length()||s[i] != '(') {
ok = false; return 0;
}
i++;
ll ret = expr(s, i);
if (i == s.length() || s[i] != ')') {
ok = false; return 0;
}
i++;
return ret;
}
ll number(string& s, int& i) {
int le = i;
while (i + 1 < s.length() && isnum(s[i + 1]))i++;
string u = s.substr(le, i - le + 1);
if (u.size() > 1 && u[0] == '0') {
ok = false; return 0;
}
i++;
return trans_num(u);
}
bool query(string &s) {
int len = s.length();
ok = true;
string le, ri;
rep(i, len) {
if (s[i] == '=') {
le = s.substr(0, i);
ri = s.substr(i+1, len-1-i);
break;
}
}
int i = 0;
ll cl = expr(le, i);
if (i != le.length())return false;
i = 0;
ll cr = expr(ri, i);
if (i != ri.length())return false;
if (!ok)return false;
return cl == cr;
}
void solve() {
string s;
cin >> s; n = s.length();
int c[52] = {};
vector<int> a(n);
rep(i, n) {
a[i] = trans(s[i]);
if (a[i] >= 0) {
c[a[i]]++;
}
}
vector<int> v;
vector<int> trans(52);
rep(i, 52) {
if (c[i]) {
trans[i] = v.size();
v.push_back(i);
}
}
if (v.size() > 8) {
cout << 0 << endl; return;
}
bool exieq = false;
rep(i, n) {
if (s[i] == '=')exieq = true;
}
int ans = 0;
if (exieq) {
if (v.size() > 7) {
cout << 0 << endl; return;
}
int num = 0;
rep(i, n)if (s[i] == '=')num++;
if (num > 1) {
cout << 0 << endl; return;
}
vector<int> b(7,7); rep(i, 7)b[i] = i;
map<vector<int>, bool> used;
while (true) {
bool f = true;
vector<int> u = b; u.resize(v.size());
if (used[u])f = false;
else used[u] = true;
if (f) {
string cop = s;
rep(i, n) {
if (a[i] >= 0) {
cop[i] = str[b[trans[a[i]]]];
}
}
//cout << cop << endl;
if (query(cop))ans++;
}
if (!next_permutation(b.begin(), b.end()))break;
}
}
else {
rep(i, v.size()) {
if (c[v[i]] != 1)continue;
string ss = s;
rep(j, n)if (a[j] == v[i])ss[j] = '=';
//cout << v[i] << " " << ss << endl;
vector<int> b(7, 7); rep(j, 7)b[j] = j;
map<vector<int>,bool> used;
while (true) {
bool f = true;
vector<int> u = b; u.resize((int)v.size() - 1);
if (used[u])f = false;
else used[u] = true;
if (f) {
string cop = ss;
rep(j, n) {
if (a[j] >= 0&&a[j]!=v[i]) {
int z = trans[a[j]];
if (a[j] > v[i])z--;
cop[j] = str[b[z]];
}
}
//cout << i<<" "<<cop << endl;
if (query(cop)) {
ans++;
//cout << "this!!" << " " << cop << endl;
//cout << "this!!" << endl;
}
}
if (!next_permutation(b.begin(), b.end()))break;
}
}
}
cout << ans << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
//string s = "-0=0";
//cout << valid(s) << endl;
//cout << fixed << setprecision(10);
solve();
//stop
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <cassert>
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <bitset>
using namespace std;
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x" = "<<(x)<<endl
#define fi first
#define se second
#define INF 2147483600
string str;
int now;
int E();
int T();
int F();
int N();
int E(){
int t = T();
if(t==INF) return INF;
while(str[now+1]=='+' || str[now+1]=='-'){
if(str[now+1]=='+'){
now++;
int p = T();
if(p==INF) return INF;
else t = t+p;
}
if(str[now+1]=='-'){
now++;
int p = T();
if(p==INF) return INF;
else t = t-p;
}
}
return t;
}
int T(){
int f = F();
if(f==INF) return INF;
if(str[now+1]=='*'){
now++;
int g = T();
if(g==INF) return INF;
else return f*g;
}
return f;
}
int F(){
int n;
switch(str[now+1]){
case '0':
case '1':
n=N();
if(n==INF) return INF;
else return n;
case '-':
now++;
n=F();
if(n==INF) return INF;
else return -n;
case '(':
now++;
n = E();
if(str[now+1]!=')' || n==INF) return INF;
now++;
return n;
default:
return INF;
}
}
int N(){
if(str[now+1]=='0'){
now++;
return 0;
}
if(str[now+1]!='1') return INF;
now++;
int res=1;
while(str[now+1]=='1' || str[now+1]=='0'){
now++;
res = res*2 + str[now] - '0';
}
return res;
}
int main(){
string s;
cin>>s;
set<char> m, mm;
string moji = "=+-*()01";
sort(all(moji));
rep(i,s.size()){
bool found=false;
rep(j,moji.size()) if(s[i]==moji[j]){
mm.insert(s[i]);
found=true;
}
if(!found) m.insert(s[i]);
}
if(m.size()>moji.size()){
cout<<0<<endl;
return 0;
}
int ans=0;
do { //next_permutation moji
string newstr(s);
auto itr = m.begin();
rep(i, m.size()){
rep(j, newstr.size()) if(newstr[j]==*itr){
newstr[j] = moji[i];
}
itr++;
}
int idx = newstr.find('=');
if(idx>0 && idx<newstr.size()-1){ // not ('=' is not found or at the head of string)
str = newstr.substr(0, idx) + '\0';
now = -1;
int l = E();
if(l!=INF && now==idx-1){
str = newstr.substr(idx+1) + '\0';
now = -1;
int r= E();
if(now==str.size()-2 && r==l) ans++;
}
}
reverse(moji.begin()+m.size(), moji.end());
} while(next_permutation(all(moji)));
cout<<ans<<endl;
return 0;
} |
#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
using namespace std;
const double EPS = 1e-5;
const double INF = 1e12;
const double PI = acos(-1);
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()
typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
L(const P& a, const P& b){ at(0)=a; at(1)=b; }
L(){}
};
struct C{
P p;
double r;
C(const P& p, const double& r) : p(p), r(r) {}
C(){}
};
namespace std{
bool operator < (const P& a, const P& b){
return !EQ(a.X,b.X) ? a.X<b.X : a.Y+EPS<b.Y;
}
bool operator == (const P& a, const P& b){
return abs(a-b) < EPS;
}
}
double dot(P a, P b){
return (conj(a)*b).X;
}
double cross(P a, P b){
return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
b -= a;
c -= a;
if(cross(b,c) > EPS) return +1; //ccw
if(cross(b,c) < -EPS) return -1; //cw
if(dot(b,c) < -EPS) return +2; //c-a-b
if(abs(c)-abs(b) > EPS) return -2; //a-b-c
return 0; //a-c-b
}
P unit(const P &p){
return p/abs(p);
}
P rotate(const P &p, double rad){
return p *P(cos(rad), sin(rad));
}
bool intersectSS(const L& a, const L& b){
return ( ccw(a[0],a[1],b[0]) *ccw(a[0],a[1],b[1]) <= 0 ) &&
( ccw(b[0],b[1],a[0]) *ccw(b[0],b[1],a[1]) <= 0 );
}
P projection(const L& l, const P& p) {
double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
return l[0] + t*(l[0]-l[1]);
}
double distanceLP(const L &l, const P &p) {
return abs(cross(l[1]-l[0], p-l[0])) /abs(l[1]-l[0]);
}
double distanceSP(const L &s, const P &p) {
if(dot(s[1]-s[0], p-s[0]) < EPS) return abs(p-s[0]);
if(dot(s[0]-s[1], p-s[1]) < EPS) return abs(p-s[1]);
return distanceLP(s, p);
}
bool isParallel(const P &a, const P &b){
return abs(cross(a,b)) < EPS;
}
bool isParallel(const L &a, const L &b){
return isParallel(a[1]-a[0], b[1]-b[0]);
}
P crosspointLL(const L &l, const L &m) {
double A = cross(l[1]-l[0], m[1]-m[0]);
double B = cross(l[1]-l[0], l[1]-m[0]);
return m[0] + B/A *(m[1]-m[0]);
}
VP crosspointCL(const C &c, const L &l){
VP ret;
P mid = projection(l, c.p);
double d = distanceLP(l, c.p);
if(EQ(d, c.r)){
ret.push_back(mid);
}else if(d < c.r){
double len = sqrt(c.r*c.r -d*d);
ret.push_back(mid +len*unit(l[1]-l[0]));
ret.push_back(mid -len*unit(l[1]-l[0]));
}
return ret;
}
vector<L> getTangentLine(const C &c, const P &p){
vector<L> ret;
P dir = p -c.p;
if(c.r +EPS < abs(dir)){
/*
P a = c.p + c.r*unit(dir);
VP cp = crosspointCL(C(c.p, abs(dir)), L(a, a+dir*P(0,1)));
for(P cpp: cp){
ret.push_back(L(p, c.p +c.r*unit(cpp-c.p)));
}
*/
double a = abs(dir);
double b = sqrt(a*a -c.r*c.r);
double psi = arg(p - c.p);
double phi = PI - acos(b/a);
ret.emplace_back(p, p + b *P(cos(psi+phi), sin(psi+phi)));
ret.emplace_back(p, p + b *P(cos(psi-phi), sin(psi-phi)));
}else if(abs(c.r -abs(dir)) < EPS){
ret.push_back(L(p, p +dir*P(0, 1)));
}
return ret;
}
struct edge{
int to, rev;
int cap;
double cost;
edge(int to, int rev, int cap, double cost)
:to(to),rev(rev),cap(cap),cost(cost){}
edge(){}
};
double min_cost_flow(int s, int g, int f, vector<vector<edge> > &adj){
int n = adj.size();
double res = 0;
while(f > 0){
vector<int> prevv(n), preve(n);
vector<double> mincost(n, INF);
mincost[s] = 0;
while(1){
bool update = false;
for(int i=0; i<n; i++){
if(mincost[i] == INF) continue;
for(int j=0; j<(int)adj[i].size(); j++){
edge &e = adj[i][j];
if(e.cap>0 && mincost[i] +e.cost +EPS < mincost[e.to]){
mincost[e.to] = mincost[i] +e.cost;
prevv[e.to] = i;
preve[e.to] = j;
update = true;
}
}
}
if(!update) break;
}
if(mincost[g] == INF){
return -1;
}
int d = f;
for(int v=g; v!=s; v=prevv[v]){
d = min(d, adj[prevv[v]][preve[v]].cap);
}
f -= d;
res += d*mincost[g];
for(int v=g; v!=s; v=prevv[v]){
edge &e = adj[prevv[v]][preve[v]];
e.cap -= d;
adj[v][e.rev].cap += d;
}
}
return res;
}
int main(){
int n;
cin >> n;
vector<C> c(2);
for(int i=0; i<2; i++){
double x,y,r;
cin >> x >> y >> r;
c[i] = C(P(x, y), r);
}
vector<VP> pos(2, VP(n));
vector<vector<vector<L> > > tangent(2, vector<vector<L> >(n));
for(int d=0; d<2; d++){
for(int i=0; i<n; i++){
double x,y;
cin >> x >> y;
pos[d][i] = P(x, y);
vector<L> ret;
for(int dd=0; dd<2; dd++){
ret = getTangentLine(c[dd], pos[d][i]);
tangent[d][i].insert(tangent[d][i].end(), ret.begin(), ret.end());
}
}
}
//1点経由でのred[i] ~blue[j]の最小距離
vector<vector<double> > dist(n, vector<double>(n, INF));
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
VP cand;
cand.push_back((pos[0][i] +pos[1][j])/2.0);
for(L t1: tangent[0][i]){
for(L t2: tangent[1][j]){
if(!isParallel(t1, t2)){
cand.push_back(crosspointLL(t1, t2));
}
}
}
for(P cp: cand){
if(distanceSP(L(pos[0][i], cp), c[0].p) +EPS > c[0].r &&
distanceSP(L(pos[0][i], cp), c[1].p) +EPS > c[1].r &&
distanceSP(L(pos[1][j], cp), c[0].p) +EPS > c[0].r &&
distanceSP(L(pos[1][j], cp), c[1].p) +EPS > c[1].r){
dist[i][j] = min(dist[i][j], abs(pos[0][i] -cp) +abs(pos[1][j] -cp));
}
}
}
}
vector<vector<edge> > adj(2*n +2);
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
if(dist[i][j] == INF) continue;
adj[i+2].emplace_back(j+2+n, adj[j+2+n].size(), 1, dist[i][j]);
adj[j+2+n].emplace_back(i+2, adj[i+2].size()-1, 0, -dist[i][j]);
}
adj[0].emplace_back(i+2, adj[i+2].size(), 1, 0);
adj[i+2].emplace_back(0, adj[0].size()-1, 0, 0);
adj[i+2+n].emplace_back(1, adj[1].size(), 1, 0);
adj[1].emplace_back(i+2+n, adj[i+2+n].size()-1, 0, 0);
}
double ans = min_cost_flow(0, 1, n, adj);
if(ans == -1){
cout << "Impossible" << endl;
}else{
cout << fixed << setprecision(10);
cout << ans << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <array>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <tuple>
#include <bitset>
#include <memory>
#include <cmath>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <numeric>
#include <climits>
#include <cfloat>
constexpr double EPS = 0.000000001;
struct Coordinate;
struct Vector;
struct Segment;
struct Angle;
struct Line;
struct Circle;
struct Coordinate {
double x, y;
double distance(const Coordinate& that) const;
Vector operator-(const Coordinate& from) const;
};
struct Vector {
double x, y;
Vector rotate(const Angle& angle) const;
double dot(const Vector& that) const;
double cross(const Vector& that) const;
double length() const;
};
Vector operator*(const double& scala, const Vector& vec);
Vector operator*(const Vector& vec, const double scala);
Coordinate operator+(const Coordinate& coord, const Vector& diff);
Coordinate operator+(const Vector& diff, const Coordinate& coord);
struct Segment {
Coordinate end_a, end_b;
bool has_intersection(const Circle& that) const;
double distance(const Coordinate& that) const;
};
struct Angle {
double sin, cos;
static Angle from_sin(const double sin);
Angle operator+(const Angle& that) const;
Angle operator-() const;
};
struct Line {
private:
const Coordinate from, to;
Vector vec() const { return to - from; }
double a() const { return to.y - from.y; }
double b() const { return from.x - to.x; }
double c() const { return - a() * from.x - from.y * b(); }
public:
Line(const Coordinate& a, const Coordinate& b) : to{ a }, from{ b } {};
bool is_cross(const Line& that) const;
Coordinate cross_point(const Line& that) const;
};
struct Circle {
Coordinate center;
double radius;
std::vector<Line> tangents(const Coordinate& that) const;
};
double Coordinate::distance(const Coordinate& that) const
{
return (*this - that).length();
}
Vector Coordinate::operator-(const Coordinate& from) const
{
return Vector{ x - from.x, y - from.y };
}
Vector Vector::rotate(const Angle& angle) const
{
auto len = length();
auto a = Angle{ y / len, x / len } + angle;
return Vector{ a.cos * len, a.sin* len };
}
double Vector::dot(const Vector& that) const
{
return x * that.x + y * that.y;
}
double Vector::cross(const Vector& that) const
{
return x * that.y - y * that.x;
}
double Vector::length() const
{
return std::sqrt(x * x + y * y);
}
Vector operator*(const double& scala, const Vector& vec)
{
return Vector{ vec.x * scala, vec.y * scala };
}
Vector operator*(const Vector& vec, const double scala)
{
return Vector{ vec.x * scala, vec.y * scala };
}
Coordinate operator+(const Coordinate& coord, const Vector& diff)
{
return Coordinate{ coord.x + diff.x, coord.y + diff.y };
}
Coordinate operator+(const Vector& diff, const Coordinate& coord)
{
return Coordinate{ diff.x + coord.x, diff.y + coord.y };
}
std::vector<Line> Circle::tangents(const Coordinate& that) const
{
const auto mid = center - that;
const auto angle = Angle::from_sin(radius / center.distance(that));
return { Line(that, mid.rotate(angle) + that), Line(that, mid.rotate(-angle) + that) };
}
bool Line::is_cross(const Line& that) const
{
return std::abs(vec().cross(that.vec())) > 0;
}
Coordinate Line::cross_point(const Line& that) const
{
const auto d = a() * that.b() - that.a() * b();
return Coordinate{ (b() * that.c() - that.b() * c()) / d, (that.a() * c() - a() * that.c()) / d };
}
Angle Angle::from_sin(const double sin)
{
return Angle{ sin, std::sqrt(1 - sin * sin) };
}
Angle Angle::operator+(const Angle& that) const
{
return Angle{ sin * that.cos + cos * that.sin, cos * that.cos - sin * that.sin };
}
Angle Angle::operator-() const
{
return Angle{ -sin, cos };
}
bool Segment::has_intersection(const Circle& that) const
{
return distance(that.center) < that.radius - EPS;
}
double Segment::distance(const Coordinate& that) const
{
const auto vec = end_a - end_b;
if (vec.dot(that - end_b) >= 0 && vec.dot(end_a - that) >= 0) {
return std::abs(vec.y * that.x - vec.x * that.y + end_a.x * end_b.y - end_a.y * end_b.x) / std::sqrt(vec.y * vec.y + vec.x * vec.x);
}
else {
return std::min(end_a.distance(that), end_b.distance(that));
}
}
struct Edge {
int to;
double cost;
Edge* pair{ nullptr };
bool has_flow;
Edge(int _to, double _cost, bool _has_flow) :to{ _to }, cost{ _cost }, has_flow{ _has_flow }{};
};
template<typename K, typename V>
struct KeyWithValue {
K key;
V value;
KeyWithValue(const K& k, const V& v) :key{ k }, value{ v }{};
};
template<typename K, typename V>
bool operator>(const KeyWithValue<K, V>& a, const KeyWithValue<K, V>& b) {
return a.key > b.key;
}
void set_edge(std::vector<std::vector<Edge>>& node, const int from, const int to, double cost) {
node[from].emplace_back(to, cost, true);
node[to].emplace_back(from, -cost, false);
node[from].back().pair = &node[to].back();
node[to].back().pair = &node[from].back();
}
double min_cost_matching(std::vector<std::vector<Edge>> &nodes, const int flow, const int source, const int sink) {
std::vector<double> min_cost(nodes.size());
std::vector<double> potential(nodes.size(), 0);
std::vector<Edge*> prev(nodes.size(), nullptr);
std::priority_queue<KeyWithValue<double, int>, std::vector<KeyWithValue<double, int>>, std::greater<KeyWithValue<double, int>>> queue;
double result = 0;
for (auto _i = 0; _i < flow; ++_i) {
std::fill(min_cost.begin(), min_cost.end(), DBL_MAX);
min_cost[source] = 0;
queue.emplace(0.0, source);
while (!queue.empty()) {
auto top = queue.top(); queue.pop();
if (top.key == min_cost[top.value]) {
for (auto& edge : nodes[top.value]) if (edge.has_flow) {
if (min_cost[edge.to] > potential[top.value] + edge.cost - potential[edge.to] + top.key + EPS) {
min_cost[edge.to] = potential[top.value] + edge.cost - potential[edge.to] + top.key;
prev[edge.to] = &edge;
queue.emplace(min_cost[edge.to], edge.to);
}
}
}
}
if (min_cost[sink] == DBL_MAX) return -1;
for (auto i = 0; i < nodes.size(); ++i) potential[i] += min_cost[i];
result += potential[sink];
auto last = sink;
while (last != source) {
auto prev_edge = prev[last];
prev_edge->has_flow = false;
prev_edge->pair->has_flow = true;
last = prev_edge->pair->to;
}
}
return result;
}
double cal_min_cost(const std::vector<Coordinate>& red, const std::vector<Coordinate>& blue, const std::vector<Circle>& circles) {
std::vector<std::vector<std::vector<Line>>> red_tangents(red.size()), blue_tangents(blue.size());
for (auto i = 0; i < red.size(); ++i) {
for (const auto &circle: circles) {
red_tangents[i].push_back(circle.tangents(red[i]));
blue_tangents[i].push_back(circle.tangents(blue[i]));
}
}
const int source = red.size() + blue.size();
const int sink = source + 1;
std::vector<std::vector<Edge>> node(sink + 1); for (auto& n : node) n.reserve(red.size() + 1);
for (auto r = 0; r < red.size(); ++r) for (auto b = 0; b < blue.size(); ++b){
const auto red_pos = red[r];
const auto blue_pos = blue[b];
double min_cost = DBL_MAX;
const auto direct = Segment{ red_pos, blue_pos };
bool is_blocked = false;
for (const auto& c : circles) if (!is_blocked) {
is_blocked = direct.has_intersection(c);
}
if (is_blocked) {
for (auto i = 0; i < circles.size(); ++i) for (auto j = 0; j < circles.size(); ++j) {
for (const auto& red_tangent : red_tangents[r][i]) for (const auto& blue_tangent : blue_tangents[b][j]) if (red_tangent.is_cross(blue_tangent)) {
const auto cross_point = red_tangent.cross_point(blue_tangent);
const auto red_to_cp = Segment{ cross_point, red_pos };
const auto blue_to_cp = Segment{ cross_point, blue_pos };
bool is_blocked = false;
for (auto c = 0; c < circles.size() && !is_blocked; ++c) {
/*
if (i == c && red_to_cp.has_intersection(circles[c])) {
std::cerr << "i: " << i << '\n';
}
if (j == c && blue_to_cp.has_intersection(circles[c])) {
std::cerr << "i: " << i << '\n';
}
*/
is_blocked = ((i != c) && red_to_cp.has_intersection(circles[c])) || ((j != c) && blue_to_cp.has_intersection(circles[c]));
}
if (!is_blocked) {
min_cost = std::min(min_cost, red_pos.distance(cross_point) + blue_pos.distance(cross_point));
}
}
}
}
else {
min_cost = red_pos.distance(blue_pos);
}
if (min_cost <= 10000) {
set_edge(node, r, b + red.size(), min_cost);
}
}
for (auto r = 0; r < red.size(); ++r) {
set_edge(node, source, r, 0);
}
for (auto b = 0; b < blue.size(); ++b) {
set_edge(node, b + red.size(), sink, 0);
}
return min_cost_matching(node, red.size(), source, sink);
}
int main() {
int n; std::cin >> n;
std::vector<Circle> circles(2); for (auto& c : circles) std::cin >> c.center.x >> c.center.y >> c.radius;
std::vector<Coordinate> red(n), blue(n);
for (auto& r : red) std::cin >> r.x >> r.y;
for (auto& b : blue) std::cin >> b.x >> b.y;
auto min_cost = cal_min_cost(red, blue, circles);
if (min_cost >= 0) {
std::cout << std::setprecision(10) << std::fixed << min_cost << '\n';
}
else {
std::cout << "Impossible\n";
}
return 0;
}
|
#include<bits/stdc++.h>
#define f first
#define s second
#define mp make_pair
#define pi acos(-1.0)
#define inf 1e09
#define eps (1e-5)
#define equals(a,b) (fabs((a)-(b))<eps)
#define MAX 300
using namespace std;
typedef pair<double,int> P;
class Point{
public:
double x,y;
Point(double x=0,double y=0):x(x),y(y){}
Point operator+(Point p){ return Point(x+p.x,y+p.y);}
Point operator-(Point p){ return Point(x-p.x,y-p.y);}
Point operator*(double k){ return Point(x*k,y*k);}
Point operator/(double k){ return Point(x/k,y/k);}
bool operator<(Point p)const{ return (x!=p.x ? x<p.x : y<p.y);}
bool operator==(Point p)const{ return fabs(x-p.x)<eps && fabs(y-p.y)<eps;}
double abs(){ return sqrt(norm());}
double norm(){ return (x*x+y*y);}
};
typedef Point Vector;
typedef vector<Point> Polygon;
class Segment{
public:
Point p1,p2;
Segment(Point p1=Point(),Point p2=Point()):p1(p1),p2(p2){}
};
typedef Segment Line;
class Circle{
public:
Point c;
double r;
Circle(Point c=Point(),double r=0.0):c(c),r(r){}
};
double norm(Vector a){ return (a.x*a.x+a.y*a.y);}
double abs(Vector a){ return sqrt(norm(a));}
double dot(Vector a,Vector b){ return (a.x*b.x+a.y*b.y);}
double cross(Vector a,Vector b){ return (a.x*b.y-a.y*b.x);}
bool isParallel(Segment a,Segment b){
return equals(cross(a.p1-a.p2,b.p1-b.p2),0.0);
}
Point getCrossPointLL(Line a,Line b){
double A=cross(a.p2-a.p1,b.p2-b.p1);
double B=cross(a.p2-a.p1,a.p2-b.p1);
if(abs(A)<eps || abs(B)<eps)return b.p1;
return b.p1+(b.p2-b.p1)*(B/A);
}
Point rotate(Point base,Point a,double r){
Point b=a-base;
a.x=b.x*cos((r/180.0)*pi)-b.y*sin((r/180.0)*pi);
a.y=b.x*sin((r/180.0)*pi)+b.y*cos((r/180.0)*pi);
a=a+base;
return a;
}
pair<Point,Point> getTangent(Circle c,Point p){
Vector v=p-c.c;
if(equals(abs(c.c-p),c.r))return mp(rotate(p,c.c,90.0),rotate(p,c.c,270.0));
double r=acos(c.r/abs(v))*360.0/(2.0*pi);
v=v*c.r/abs(v);
Point p1=rotate(c.c,c.c+v,r);
Point p2=rotate(c.c,c.c+v,360.0-r);
return mp(p1,p2);
}
double getDistanceLP(Line l,Point p){
return abs(cross(l.p2-l.p1,p-l.p1)/abs(l.p2-l.p1));
}
double getDistanceSP(Segment s,Point p){
if(dot(s.p2-s.p1,p-s.p1)<0.0)return abs(p-s.p1);
if(dot(s.p1-s.p2,p-s.p2)<0.0)return abs(p-s.p2);
return getDistanceLP(s,p);
}
bool intersect(Circle c,Segment s){
if(getDistanceSP(s,c.c)-c.r<-eps)return true;
return false;
}
int n;
Circle R,B;
vector<Point> r,b;
vector<Line> getS(Point p){
vector<Line> res;
pair<Point,Point> pp=getTangent(R,p);
res.push_back(Line(p,pp.f));
res.push_back(Line(p,pp.s));
pp=getTangent(B,p);
res.push_back(Line(p,pp.f));
res.push_back(Line(p,pp.s));
return res;
}
double getdis(int c,int d){
Segment s(r[c],b[d]);
if(!intersect(R,s) && !intersect(B,s))return abs(r[c]-b[d]);
vector<Line> vs1=getS(r[c]),vs2=getS(b[d]);
double res=inf;
for(int i=0;i<vs1.size();i++){
for(int j=0;j<vs2.size();j++){
if(isParallel(vs1[i],vs2[j]))continue;
Point m=getCrossPointLL(vs1[i],vs2[j]);
if(!intersect(R,Segment(r[c],m)) && !intersect(B,Segment(m,b[d])) &&
!intersect(B,Segment(r[c],m)) && !intersect(R,Segment(m,b[d])))
res=min(res,abs(r[c]-m)+abs(m-b[d]));
}
}
return res;
}
struct edge{
int to,cap;
double cost;
int rev;
};
int v;
vector<edge> e[MAX];
double h[MAX];
double dist[MAX];
int prevv[MAX],preve[MAX];
void add_edge(int from,int to,int cap,double cost){
e[from].push_back((edge){to,cap,cost,(int)e[to].size()});
e[to].push_back((edge){from,0,-cost,(int)e[from].size()-1});
}
double min_cost_flow(int s,int t,int f){
double res=0.0;
fill(h,h+v,0);
while(f>0){
priority_queue<P,vector<P>,greater<P> > pq;
fill(dist,dist+v,inf);
dist[s]=0;
pq.push(P(0,s));
while(pq.size()){
P p=pq.top();
pq.pop();
int u=p.second;
if(dist[u]-p.first<-eps)continue;
for(int i=0;i<e[u].size();i++){
edge &E=e[u][i];
if(E.cap>0 && (dist[u]+E.cost+h[u]-h[E.to])-dist[E.to]<-eps){
dist[E.to]=dist[u]+E.cost+h[u]-h[E.to];
prevv[E.to]=u;
preve[E.to]=i;
pq.push(P(dist[E.to],E.to));
}
}
}
if(dist[t]==inf)return -1;
for(int i=0;i<v;i++)h[i]+=dist[i];
int d=f;
for(int u=t;u!=s;u=prevv[u]){
d=min(d,e[prevv[u]][preve[u]].cap);
}
f-=d;
res+=(double)d*h[t];
for(int u=t;u!=s;u=prevv[u]){
edge &E=e[prevv[u]][preve[u]];
E.cap-=d;
e[u][E.rev].cap+=d;
}
}
return res;
}
int main()
{
cin>>n;
cin>>R.c.x>>R.c.y>>R.r;
cin>>B.c.x>>B.c.y>>B.r;
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
r.push_back(Point(x,y));
}
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
b.push_back(Point(x,y));
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
double d=getdis(i,j);
if(d!=inf)add_edge(i,j+n,1,d);
}
}
int s=n*2;
int t=s+1;
v=t+1;
for(int i=0;i<n;i++){
add_edge(s,i,1,0);
add_edge(i+n,t,1,0);
}
double res=min_cost_flow(s,t,n);
if(equals(res,-1.0))cout<<"Impossible"<<endl;
else printf("%.10f\n",res);
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
using ld = double;
using Point = std::complex<ld>;
const ld eps = 1e-9, pi = acos(-1.0);
namespace std
{
bool operator<(const Point &lhs, const Point &rhs)
{
if (lhs.real() < rhs.real() - eps)
return true;
if (lhs.real() > rhs.real() + eps)
return false;
return lhs.imag() < rhs.imag();
}
} // namespace std
Point input_point()
{
ld x, y;
std::cin >> x >> y;
return Point(x, y);
}
bool eq(ld a, ld b)
{
return (abs(a - b) < eps);
}
ld dot(Point a, Point b)
{
return real(conj(a) * b);
}
ld cross(Point a, Point b)
{
return imag(conj(a) * b);
}
// CCW::counter clockwise
int ccw(Point a, Point b, Point c)
{
b -= a;
c -= a;
if (cross(b, c) > eps)
return 1; // a,b,c : counter-clockwise
if (cross(b, c) < -eps)
return -1; // a,b,c : clockwise
if (dot(b, c) < 0)
return 2; // c,a,b : on a line
if (norm(b) < norm(c))
return -2; // a,b,c : on a line
return 0; // a,c,b : on a line
}
class Line
{
public:
Point a, b;
Line() : a(Point(0, 0)), b(Point(0, 0)) {}
Line(Point a, Point b) : a(a), b(b) {}
};
ld dot(Line l, Line m)
{
return dot((l.a - l.b), (m.a - m.b));
}
// l:line, m:line が交点を持つか
bool isis_ll(Line l, Line m)
{
return !eq(cross(l.b - l.a, m.b - m.a), 0);
}
// l:line, s:segment
bool isis_ls(Line l, Line s)
{
return isis_ll(l, s) &&
(cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < eps);
}
// s:segment, t:segment
bool isis_ss(Line s, Line t)
{
return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
// p が l:line 上に存在するか
bool isis_lp(Line l, Point p)
{
return (abs(cross(l.b - p, l.a - p)) < eps);
}
bool isis_sp(Line s, Point p)
{
return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps);
}
// p から l に下ろした足との交点
Point proj(Line l, Point p)
{
ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
return l.a + t * (l.a - l.b);
}
// l:line, t:line の交点
Point is_ll(Line l, Line m)
{
Point lv = l.b - l.a, mv = m.b - m.a;
assert(cross(lv, mv) != 0);
return l.a + lv * cross(mv, m.a - l.a) / cross(mv, lv);
}
// p, l:line の距離
ld dist_lp(Line l, Point p)
{
return abs(p - proj(l, p));
}
ld dist_ll(Line l, Line m)
{
return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
}
ld dist_ls(Line l, Line s)
{
return isis_ls(l, s) ? 0 : std::min(dist_lp(l, s.a), dist_lp(l, s.b));
}
ld dist_sp(Line s, Point p)
{
Point r = proj(s, p);
return isis_sp(s, r) ? abs(r - p) : std::min(abs(s.a - p), abs(s.b - p));
}
ld dist_ss(Line s, Line t)
{
if (isis_ss(s, t))
return 0;
return std::min({dist_sp(s, t.a), dist_sp(s, t.b), dist_sp(t, s.a), dist_sp(t, s.b)});
}
class Circle
{
public:
Point p;
ld r;
Circle() : p(Point(0, 0)), r(0) {}
Circle(Point p, ld r) : p(p), r(r) {}
};
// c1, c2 の交点
std::vector<Point> is_cc(Circle c1, Circle c2)
{
std::vector<Point> res;
ld d = abs(c1.p - c2.p);
ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
ld dfr = c1.r * c1.r - rc * rc;
if (abs(dfr) < eps)
dfr = 0.0;
else if (dfr < 0.0)
return res; // no intersection
ld rs = sqrt(dfr);
Point diff = (c2.p - c1.p) / d;
res.emplace_back(c1.p + diff * Point(rc, rs));
if (dfr != 0.0)
res.emplace_back(c1.p + diff * Point(rc, -rs));
return res;
}
std::vector<Point> is_lc(Circle c, Line l)
{
std::vector<Point> res;
ld d = dist_lp(l, c.p);
if (d < c.r + eps)
{
ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); //safety;
Point nor = (l.a - l.b) / abs(l.a - l.b);
res.emplace_back(proj(l, c.p) + len * nor);
res.emplace_back(proj(l, c.p) - len * nor);
}
return res;
}
std::vector<Point> is_sc(Circle c, Line l)
{
std::vector<Point> v = is_lc(c, l), res;
for (Point p : v)
if (isis_sp(l, p))
res.emplace_back(p);
return res;
}
// p から c への接線
std::vector<Line> tangent_cp(Circle c, Point p)
{
std::vector<Line> ret;
Point v = c.p - p;
ld d = abs(v);
ld l = sqrt(norm(v) - c.r * c.r);
if (isnan((long double)l))
{
return ret;
}
Point v1 = v * Point(l / d, c.r / d);
Point v2 = v * Point(l / d, -c.r / d);
ret.emplace_back(Line(p, p + v1));
if (l < eps)
return ret;
ret.emplace_back(Line(p, p + v2));
return ret;
}
bool isContain(Circle c, Line l)
{
return dist_sp(l, c.p) + eps < c.r;
}
class minCostFlow
{
using capacity_type = int;
using cost_type = double;
using pii = std::pair<cost_type, int>;
const int INF = 1e9;
struct Edge
{
int to, rev;
capacity_type cap;
cost_type cost;
Edge(int to_, int _rev, capacity_type cap_, cost_type cost_)
: to(to_), rev(_rev), cap(cap_), cost(cost_) {}
};
int V;
std::vector<std::vector<Edge>> G;
// ポテンシャル
std::vector<cost_type> h;
// 最短距離
std::vector<cost_type> dist;
// 直前の頂点, 辺
std::vector<int> prevv, preve;
public:
minCostFlow(int _V) : V(_V), G(_V), h(_V), dist(_V), prevv(_V), preve(_V) {}
void add(int from, int to, capacity_type cap, cost_type cost)
{
G[from].push_back(Edge(to, G[to].size(), cap, cost));
G[to].push_back(Edge(from, G[from].size() - 1, 0, -cost));
}
cost_type calc(int s, int t, int f)
{
cost_type res = 0;
fill(h.begin(), h.end(), 0);
while (f > 0)
{
std::priority_queue<pii, std::vector<pii>, std::greater<pii>> que;
fill(dist.begin(), dist.end(), INF);
dist[s] = 0;
que.push(pii(0, s));
while (!que.empty())
{
pii p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (size_t i = 0; i < G[v].size(); i++)
{
Edge &e = G[v][i];
if (e.cap > eps && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to] + eps)
{
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(pii(dist[e.to], e.to));
}
}
}
if (dist[t] == INF)
return -1;
for (int v = 0; v < V; v++)
h[v] += dist[v];
capacity_type d = f;
for (int v = t; v != s; v = prevv[v])
{
d = std::min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v])
{
Edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
};
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ld x1, y1, r1, x2, y2, r2;
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2;
Circle c1(Point(x1, y1), r1), c2(Point(x2, y2), r2);
vector<Point> rs, bs;
for (int i = 0; i < n; i++)
{
rs.push_back(input_point());
}
for (int i = 0; i < n; i++)
{
bs.push_back(input_point());
}
// dist[i][j] := rs[i], bs[j] の最短移動距離
vector<vector<ld>> dist(n, vector<ld>(n, 1e15));
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
Line l = Line(rs[i], bs[j]);
if (is_sc(c1, l).size() <= 1 && is_sc(c2, l).size() <= 1)
{
dist[i][j] = abs(rs[i] - bs[j]);
continue;
}
// rs[i] から c1 への接線
auto rl1 = tangent_cp(c1, rs[i]);
// bs[j] から c1 への接線
auto bl1 = tangent_cp(c1, bs[j]);
// rs[i], c2 への接線
auto rl2 = tangent_cp(c2, rs[i]);
// bs[j], c2 への接線
auto bl2 = tangent_cp(c2, bs[j]);
for (auto l1 : rl1)
{
for (auto l2 : bl1)
{
Point lv = l1.b - l1.a, mv = l2.b - l2.a;
if (cross(lv, mv) == 0)
continue;
Point p = is_ll(l1, l2);
if (isContain(c2, Line(rs[i], p)) || isContain(c2, Line(bs[j], p)))
continue;
dist[i][j] = min(dist[i][j], abs(p - rs[i]) + abs(p - bs[j]));
}
}
for (auto l1 : rl2)
{
for (auto l2 : bl2)
{
Point lv = l1.b - l1.a, mv = l2.b - l2.a;
if (cross(lv, mv) == 0)
continue;
Point p = is_ll(l1, l2);
if (isContain(c1, Line(rs[i], p)) || isContain(c1, Line(bs[j], p)))
continue;
dist[i][j] = min(dist[i][j], abs(p - rs[i]) + abs(p - bs[j]));
}
}
// rs[i]-c1, bs[j]-c2
for (auto l1 : rl1)
{
for (auto l2 : bl2)
{
Point lv = l1.b - l1.a, mv = l2.b - l2.a;
if (cross(lv, mv) == 0)
continue;
Point p = is_ll(l1, l2);
if (isContain(c2, Line(rs[i], p)) || isContain(c1, Line(bs[j], p)))
continue;
dist[i][j] = min(dist[i][j], abs(p - rs[i]) + abs(p - bs[j]));
}
}
// rs[i]-c2, bs[j]-c1
for (auto l1 : rl2)
{
for (auto l2 : bl1)
{
Point lv = l1.b - l1.a, mv = l2.b - l2.a;
if (cross(lv, mv) == 0)
continue;
Point p = is_ll(l1, l2);
if (isContain(c1, Line(rs[i], p)) || isContain(c2, Line(bs[j], p)))
continue;
dist[i][j] = min(dist[i][j], abs(p - rs[i]) + abs(p - bs[j]));
}
}
}
}
minCostFlow mcf(2 * n + 2);
for (int i = 0; i < n; i++)
{
mcf.add(0, i + 1, 1, 0);
mcf.add(n + i + 1, 2 * n + 1, 1, 0);
for (int j = 0; j < n; j++)
{
int st = i + 1, gt = n + 1 + j;
if (dist[i][j] != 1e15)
{
mcf.add(st, gt, 1, dist[i][j]);
}
}
}
auto ret = mcf.calc(0, 2 * n + 1, n);
if (ret == -1)
cout << "Impossible" << endl;
else
cout << fixed << setprecision(10) << ret << endl;
}
|
#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
using namespace std;
const double EPS = 1e-5;
const double INF = 1e12;
const double PI = acos(-1);
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()
typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
L(const P& a, const P& b){ at(0)=a; at(1)=b; }
L(){}
};
struct C{
P p;
double r;
C(const P& p, const double& r) : p(p), r(r) {}
C(){}
};
namespace std{
bool operator < (const P& a, const P& b){
return !EQ(a.X,b.X) ? a.X<b.X : a.Y+EPS<b.Y;
}
bool operator == (const P& a, const P& b){
return abs(a-b) < EPS;
}
}
double dot(P a, P b){
return (conj(a)*b).X;
}
double cross(P a, P b){
return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
b -= a;
c -= a;
if(cross(b,c) > EPS) return +1; //ccw
if(cross(b,c) < -EPS) return -1; //cw
if(dot(b,c) < -EPS) return +2; //c-a-b
if(abs(c)-abs(b) > EPS) return -2; //a-b-c
return 0; //a-c-b
}
P unit(const P &p){
return p/abs(p);
}
P rotate(const P &p, double rad){
return p *P(cos(rad), sin(rad));
}
bool intersectSS(const L& a, const L& b){
return ( ccw(a[0],a[1],b[0]) *ccw(a[0],a[1],b[1]) <= 0 ) &&
( ccw(b[0],b[1],a[0]) *ccw(b[0],b[1],a[1]) <= 0 );
}
P projection(const L& l, const P& p) {
double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
return l[0] + t*(l[0]-l[1]);
}
double distanceLP(const L &l, const P &p) {
return abs(cross(l[1]-l[0], p-l[0])) /abs(l[1]-l[0]);
}
double distanceSP(const L &s, const P &p) {
if(dot(s[1]-s[0], p-s[0]) < EPS) return abs(p-s[0]);
if(dot(s[0]-s[1], p-s[1]) < EPS) return abs(p-s[1]);
return distanceLP(s, p);
}
bool isParallel(const P &a, const P &b){
return abs(cross(a,b)) < EPS;
}
bool isParallel(const L &a, const L &b){
return isParallel(a[1]-a[0], b[1]-b[0]);
}
P crosspointLL(const L &l, const L &m) {
double A = cross(l[1]-l[0], m[1]-m[0]);
double B = cross(l[1]-l[0], l[1]-m[0]);
return m[0] + B/A *(m[1]-m[0]);
}
VP crosspointCL(const C &c, const L &l){
VP ret;
P mid = projection(l, c.p);
double d = distanceLP(l, c.p);
if(EQ(d, c.r)){
ret.push_back(mid);
}else if(d < c.r){
double len = sqrt(c.r*c.r -d*d);
ret.push_back(mid +len*unit(l[1]-l[0]));
ret.push_back(mid -len*unit(l[1]-l[0]));
}
return ret;
}
vector<L> getTangentLine(const C &c, const P &p){
vector<L> ret;
P dir = p -c.p;
if(c.r +EPS < abs(dir)){
P a = c.p + c.r*unit(dir);
VP cp = crosspointCL(C(c.p, abs(dir)), L(a, a+dir*P(0,1)));
for(P cpp: cp){
ret.push_back(L(p, c.p +c.r*unit(cpp-c.p)));
}
}else if(abs(c.r -abs(dir)) < EPS){
ret.push_back(L(p, p +dir*P(0, 1)));
}
return ret;
}
struct edge{
int to, rev;
int cap;
double cost;
edge(int to, int rev, int cap, double cost)
:to(to),rev(rev),cap(cap),cost(cost){}
edge(){}
};
double min_cost_flow(int s, int g, int f, vector<vector<edge> > &adj){
int n = adj.size();
double res = 0;
while(f > 0){
vector<int> prevv(n), preve(n);
vector<double> mincost(n, INF);
mincost[s] = 0;
while(1){
bool update = false;
for(int i=0; i<n; i++){
if(mincost[i] == INF) continue;
for(int j=0; j<(int)adj[i].size(); j++){
edge &e = adj[i][j];
if(e.cap>0 && mincost[i] +e.cost +EPS < mincost[e.to]){
mincost[e.to] = mincost[i] +e.cost;
prevv[e.to] = i;
preve[e.to] = j;
update = true;
}
}
}
if(!update) break;
}
if(mincost[g] == INF){
return -1;
}
int d = f;
for(int v=g; v!=s; v=prevv[v]){
d = min(d, adj[prevv[v]][preve[v]].cap);
}
f -= d;
res += d*mincost[g];
for(int v=g; v!=s; v=prevv[v]){
edge &e = adj[prevv[v]][preve[v]];
e.cap -= d;
adj[v][e.rev].cap += d;
}
}
return res;
}
int main(){
int n;
cin >> n;
vector<C> c(2);
for(int i=0; i<2; i++){
double x,y,r;
cin >> x >> y >> r;
c[i] = C(P(x, y), r);
}
vector<VP> pos(2, VP(n));
vector<vector<vector<L> > > tangent(2, vector<vector<L> >(n));
for(int d=0; d<2; d++){
for(int i=0; i<n; i++){
double x,y;
cin >> x >> y;
pos[d][i] = P(x, y);
vector<L> ret;
for(int dd=0; dd<2; dd++){
ret = getTangentLine(c[dd], pos[d][i]);
tangent[d][i].insert(tangent[d][i].end(), ret.begin(), ret.end());
}
}
}
//1点経由でのred[i] ~blue[j]の最小距離
vector<vector<double> > dist(n, vector<double>(n, INF));
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
VP cand;
cand.push_back((pos[0][i] +pos[1][j])/2.0);
for(L t1: tangent[0][i]){
for(L t2: tangent[1][j]){
if(!isParallel(t1, t2)){
cand.push_back(crosspointLL(t1, t2));
}
}
}
for(P cp: cand){
if(distanceSP(L(pos[0][i], cp), c[0].p) +EPS > c[0].r &&
distanceSP(L(pos[0][i], cp), c[1].p) +EPS > c[1].r &&
distanceSP(L(pos[1][j], cp), c[0].p) +EPS > c[0].r &&
distanceSP(L(pos[1][j], cp), c[1].p) +EPS > c[1].r){
dist[i][j] = min(dist[i][j], abs(pos[0][i] -cp) +abs(pos[1][j] -cp));
}
}
}
}
vector<vector<edge> > adj(2*n +2);
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
if(dist[i][j] == INF) continue;
adj[i+2].emplace_back(j+2+n, adj[j+2+n].size(), 1, dist[i][j]);
adj[j+2+n].emplace_back(i+2, adj[i+2].size()-1, 0, -dist[i][j]);
}
adj[0].emplace_back(i+2, adj[i+2].size(), 1, 0);
adj[i+2].emplace_back(0, adj[0].size()-1, 0, 0);
adj[i+2+n].emplace_back(1, adj[1].size(), 1, 0);
adj[1].emplace_back(i+2+n, adj[i+2+n].size()-1, 0, 0);
}
double ans = min_cost_flow(0, 1, n, adj);
if(ans == -1){
cout << "Impossible" << endl;
}else{
cout << fixed << setprecision(10);
cout << ans << endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <queue>
constexpr double EPS = 1e-5;
constexpr int MAX_V = 300;
constexpr int INF = 1e9;
using P = std::pair<double, int>;
template<class T>
using vec = std::vector<T>;
#define equals(a, b) (fabs(a - b) < EPS)
struct Point {
double x, y;
Point(){}
Point(double x, double y) : x{x}, y{y} {}
Point operator + (const Point &p) const
{
return Point{x + p.x, y + p.y};
}
Point operator - (const Point &p) const
{
return Point{x - p.x, y - p.y};
}
Point operator * (const double &k) const
{
return Point{x * k, y * k};
}
bool operator == (const Point &p) const
{
return (equals(x, p.x) && equals(y, p.y));
}
};
double dot(const Point &a, const Point &b)
{
return a.x * b.x + a.y * b.y;
}
double cross(const Point &a, const Point &b)
{
return a.x * b.y - b.x * a.y;
}
double norm(const Point &p)
{
return dot(p, p);
}
double abs(const Point &p)
{
return sqrt(norm(p));
}
double dist(const Point &a, const Point &b)
{
return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}
Point rotate90(const Point &p)
{
return Point(-p.y, p.x);
}
constexpr int COUNTER_CLOCKWISE = +1;
constexpr int CLOCKWISE = -1;
constexpr int ONLINE_BACK = +2;
constexpr int ONLINE_FRONT = -2;
constexpr int ON_SEGMENT = +0;
using Vector = Point;
int ccw(const Point &p0, const Point &p1, const Point &p2)
{
Vector a = p1 - p0;
Vector b = p2 - p0;
if (cross(a, b) > EPS) return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS) return CLOCKWISE;
if (dot(a, b) < -EPS) return ONLINE_BACK;
if (norm(a) < norm(b)) return ONLINE_FRONT;
return ON_SEGMENT;
}
struct Segment {
Point s, t;
Segment () {}
Segment (Point s, Point t) : s{s}, t{t} {}
};
using Line = Segment;
bool isIntersect(const Line &a, const Line &b)
{
return (abs(cross(a.t - a.s, b.t - b.s)) > EPS ||
abs(cross(a.t - a.s, b.t - b.s)) < EPS);
}
Point crosspoint(const Line &a, const Line &b)
{
Vector va = a.t - a.s, vb = b.t - b.s;
double d = cross(vb, va);
if (abs(d) < EPS) return b.s;
return a.s + va * cross(vb, b.t - a.s) * (1.0 / d);
}
struct Circle {
Point p;
double r;
Circle () {}
Circle (Point p, double r) : p{p}, r{r} {}
};
vec<Point> tangent(const Circle &c, const Point &p)
{
double x = norm(p - c.p), d = x - c.r * c.r;
if (d < -EPS) return vec<Point>{};
d = std::max(d, 0.0);
Point p1 = (p - c.p) * (c.r * c.r / x);
Point p2 = rotate90((p - c.p) * (-c.r * sqrt(d) / x));
vec<Point> res;
res.emplace_back(c.p + p1 - p2);
res.emplace_back(c.p + p1 + p2);
return res;
}
bool isIntersect(const Segment &s, const Point &p)
{
return (ccw(s.s, s.t, p) == ON_SEGMENT);
}
Point projection(const Segment &s, const Point &p)
{
Point b = s.t - s.s;
double t = dot(p - s.s, b) / norm(b);
return s.s + b * t;
}
double distance(const Segment &s, const Point &p)
{
Point r = projection(s, p);
if (isIntersect(s, r)) return abs(r - p);
return std::min(abs(s.s - p), abs(s.t - p));
}
bool isIntersect(const Circle &c, const Segment &s)
{
double d = distance(s, c.p);
return (d < c.r - EPS);
}
struct edge {
int to, cap, rev;
double cost;
edge(int to, int cap, int rev, double cost) :
to(to), cap(cap), rev(rev), cost(cost) {}
};
int V, prevv[MAX_V], preve[MAX_V];
double h[MAX_V], dst[MAX_V];
vec<edge> G[MAX_V];
void add_edge(int from, int to, int cap, double cost)
{
G[from].emplace_back(edge(to, cap, G[to].size(), cost));
G[to].emplace_back(edge(from, 0, G[from].size() - 1, -cost));
}
double min_cost_flow(int s, int t, int f)
{
double res = 0;
std::fill(h, h + V, 0);
while (f > 0) {
std::priority_queue<P, vec<P>, std::greater<P>> pq;
std::fill(dst, dst + V, INF);
dst[s] = 0; pq.push(P(0, s));
while (!pq.empty()) {
P p = pq.top(); pq.pop();
int v = p.second;
if (dst[v] < p.first) continue;
for (int i = 0; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dst[e.to] > dst[v] + e.cost + h[v] - h[e.to] + EPS) {
dst[e.to] = dst[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v; preve[e.to] = i;
pq.push(P(dst[e.to], e.to));
}
}
}
if (dst[t] == INF) return -1;
for (int v = 0; v < V; v++) {
h[v] += dst[v];
}
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = std::min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int main()
{
int N;
vec<Circle> c(2);
std::cin >> N;
for (int i = 0; i < 2; i++) {
std::cin >> c[i].p.x >> c[i].p.y >> c[i].r;
}
vec<Point> r(N), b(N);
for (int i = 0; i < N; i++) {
std::cin >> r[i].x >> r[i].y;
}
for (int i = 0; i < N; i++) {
std::cin >> b[i].x >> b[i].y;
}
int S = N * 2, T = S + 1;
V = N * 2 + 2;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
Segment s(r[i], b[j]);
double d = INF;
if (!isIntersect(c[0], s) && !isIntersect(c[1], s)) {
d = std::min(d, dist(r[i], b[j]));
}
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
vec<Point> vp1 = tangent(c[k], r[i]);
vec<Point> vp2 = tangent(c[l], b[j]);
for (int m = 0; m < (int)vp1.size(); m++) {
for (int n = 0; n < (int)vp2.size(); n++) {
Line l1{r[i], vp1[m]}, l2{b[j], vp2[n]};
if (r[i] == vp1[m]) {
Point p1 = vp1[m] - c[k].p;
l1.t = vp1[m] + rotate90(p1);
}
if (b[j] == vp2[n]) {
Point p2 = vp2[n] - c[l].p;
l2.t = vp2[n] + rotate90(p2);
}
if (isIntersect(l1, l2)) {
Point cp = crosspoint(l1, l2);
Segment s1(r[i], cp), s2(b[j], cp);
if (!isIntersect(c[k], s1) &&
!isIntersect(c[l], s2) &&
!isIntersect(c[1 - k], s1) &&
!isIntersect(c[1 - l], s2)) {
d = std::min(d, dist(r[i], cp) + dist(b[j], cp));
}
}
}
}
}
}
if (d != INF) {
add_edge(i, j + N, 1, d);
}
}
}
for (int i = 0; i < N; i++) {
add_edge(S, i, 1, 0);
add_edge(i + N, T, 1, 0);
}
double res = min_cost_flow(S, T, N);
if (res == -1) {
printf("Impossible\n");
} else {
printf("%.10f\n", res);
}
return 0;
} |
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<utility>
#include<map>
#include<complex>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef vector<int> vec;
#define rep(i,n) for(int i=0;i<n;i++)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define stop char nyaa;cin>>nyaa;
#define per(i,n) for(int i=n-1;i>=0;i--)
//geometry
typedef long double ld;
typedef complex<ld> Point;
const ld pi = acos(-1.0);
const ld eps = 1e-9;
bool eq(ld a, ld b) {
return abs(a - b) < eps;
}
ld dot(Point a, Point b) { return real(conj(a)*b); }
ld cross(Point a, Point b) { return imag(conj(a)*b); }
struct Line {
Point a, b;
};
struct Circle {
Point p; ld r;
};
bool isis_ll(Line l, Line m) {
return !eq(cross(l.b - l.a, m.b - m.a), 0);
}
bool isis_sp(Line s, Point p) {
return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps);
}
Point proj(Line l, Point p) {
ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
return l.a + t * (l.a - l.b);
}
ld dist_lp(Line l, Point p) {
return abs(p - proj(l, p));
}
ld dist_sp(Line s, Point p) {
Point r = proj(s, p);
return isis_sp(s, r) ? abs(p - r) : min(abs(p - s.a), abs(p - s.b));
}
Point is_ll(Line s, Line t) {
Point sv = s.b - s.a;
Point tv = t.b - t.a;
return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
vector<Line> tangent_cp(Circle c, Point p) {
vector<Line> res;
Point v = c.p - p;
ld d = abs(v);
ld l = sqrt(norm(v) - c.r*c.r);
if (isnan(l))return res;
Point v1 = v * Point(l / d, c.r / d);
Point v2 = v * Point(l / d, -c.r / d);
res.push_back(Line{ p,p + v1 });
if (l < eps)return res;
res.push_back(Line{ p,p + v2 });
return res;
}
int max_n;
const int mn = 100000;
struct edge {
int to, cap; ld cost; int rev;
};
typedef pair<ld, int> speP;
vector<edge> G[mn];
int par[mn];
ld dist[mn];
void add_edge(int from, int to, int cap, ld cost) {
G[from].push_back({ to,cap,cost,(int)G[to].size() });
G[to].push_back({ from,0,-cost,(int)G[from].size()-1 });
max_n = max({ max_n,from + 1,to + 1 });
}
ld minimum_road(int s, int t) {
fill(par, par + max_n, -1);
fill(dist, dist + max_n, mod);
dist[s] = 0;
priority_queue<speP, vector<speP>, greater<speP>> q;
q.push({ 0,s });
while (!q.empty()) {
speP p = q.top(); q.pop();
int id = p.second;
if (id == t)continue;
if (p.first > dist[id])continue;
rep(j, G[id].size()) {
if (G[id][j].cap > 0) {
int to = G[id][j].to;
ld nd = p.first + G[id][j].cost;
if (nd < dist[to]) {
dist[to] = nd;
par[to] = id;
q.push({ dist[to],to });
}
}
}
}
int cur = t;
while (cur != s) {
int p = par[cur];
if (p < 0)return -1;
rep(j, G[p].size()) {
if (G[p][j].cap > 0 && G[p][j].to == cur && dist[p] + G[p][j].cost == dist[cur]) {
G[p][j].cap--;
G[cur][G[p][j].rev].cap++;
break;
}
}
cur = p;
}
return dist[t];
}
ld minimum_cost_flow(int s, int t, int k) {
ld ret = 0;
rep(i, k) {
ld z = minimum_road(s, t);
if (z < 0)return -1;
ret += z;
}
return ret;
}
bool isis_cs(Circle c, Line s) {
ld dist = dist_sp(s,c.p);
return dist < c.r - eps;
}
vector<Circle> c;
void solve() {
int n; cin >> n;
c.resize(2);
rep(i, 2) {
ld x, y, r; cin >> x >> y >> r;
c[i] = { {x,y},r };
}
vector<Point> a(n), b(n);
rep(i, n) {
ld x, y; cin >> x >> y;
a[i] = { x,y };
}
rep(i, n) {
ld x, y; cin >> x >> y;
b[i] = { x,y };
}
int s = 2 * n, t = 2 * n + 1;
rep(i, n) {
add_edge(s, i, 1, 0);
add_edge(i + n,t, 1, 0);
}
vector<vector<Line>> l(n), r(n);
rep(i, n) {
rep(j, 2) {
vector<Line> u = tangent_cp(c[j], a[i]);
rep(k, u.size())l[i].push_back(u[k]);
u = tangent_cp(c[j], b[i]);
rep(k, u.size())r[i].push_back(u[k]);
}
}
rep(i, n) {
rep(j, n) {
Point le = a[i], ri = b[j];
ld cost = mod;
{
Line l = { le,ri };
bool f = true;
rep(k, 2) {
if (isis_cs(c[k], l))f = false;
}
if (f) {
cost = abs(ri - le);
add_edge(i, n + j, 1, cost);
continue;
}
}
rep(k1, l[i].size()) {
rep(k2,r[j].size()) {
Line lle = l[i][k1];
Line rri = r[j][k2];
if (!isis_ll(lle, rri))continue;
Point cn = is_ll(lle, rri);
Line sl = { le,cn };
Line sr = { ri,cn };
bool valid = true;
rep(k, 2) {
if (isis_cs(c[k], sl) || isis_cs(c[k], sr)) {
valid = false; break;
}
}
if (valid) {
cost = min(cost, abs(cn - le) + abs(cn - ri));
}
}
}
if (cost == mod)continue;
add_edge(i, n + j, 1, cost);
}
}
ld ans = minimum_cost_flow(s, t, n);
if (ans == -1) {
cout << "Impossible" << endl;
}
else {
cout << ans << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
solve();
//stop
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define EPS (1e-5)
#define equals(a, b) (fabs(a-b) < EPS)
#define MAX_V 300
#define INF 1e9
typedef pair<double, int> P;
struct Point {
double x, y;
Point(){}
Point(double x, double y) : x(x), y(y) {}
Point operator + (const Point &p) const { return Point(x + p.x, y + p.y); }
Point operator - (const Point &p) const { return Point(x - p.x, y - p.y); }
Point operator * (const double &k) const { return Point(x * k, y * k); }
bool operator == (const Point &p) const {
return (equals(x, p.x) && equals(y, p.y));
}
};
double dot(const Point &a, const Point &b)
{
return a.x * b.x + a.y * b.y;
}
double cross(const Point &a, const Point &b)
{
return a.x * b.y - b.x * a.y;
}
double norm(const Point &p)
{
return dot(p, p);
}
double abs(const Point &p)
{
return sqrt(norm(p));
}
double dist(const Point &a, const Point &b)
{
return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}
Point rotate90(const Point &p)
{
return Point(-p.y, p.x);
}
#define COUNTER_CLOCKWISE +1
#define CLOCKWISE -1
#define ONLINE_BACK +2
#define ONLINE_FRONT -2
#define ON_SEGMENT +0
typedef Point Vector;
int ccw(const Point &p0, const Point &p1, const Point &p2)
{
Vector a = p1 - p0;
Vector b = p2 - p0;
if(cross(a, b) > EPS) return COUNTER_CLOCKWISE;
if(cross(a, b) < -EPS) return CLOCKWISE;
if(dot(a, b) < -EPS) return ONLINE_BACK;
if(norm(a) < norm(b)) return ONLINE_FRONT;
return ON_SEGMENT;
}
struct Segment {
Point s, t;
Segment () {}
Segment (Point s, Point t) : s(s), t(t) {}
};
typedef Segment Line;
bool isIntersectLL(const Line &a, const Line &b)
{
return (abs(cross(a.t - a.s, b.t - b.s)) > EPS ||
abs(cross(a.t - a.s, b.t - b.s)) < EPS);
}
Point crosspointLL(const Line &a, const Line &b)
{
Vector va = a.t - a.s, vb = b.t - b.s;
double d = cross(vb, va);
if (abs(d) < EPS) return b.s;
return a.s + va * cross(vb, b.t - a.s) * (1.0 / d);
}
struct Circle {
Point p;
double r;
Circle () {}
Circle (Point p, double r) : p(p), r(r) {}
};
vector<Point> tangentCP(const Circle &c, const Point &p)
{
double x = norm(p - c.p), d = x - c.r * c.r;
if (d < -EPS) return vector<Point>();
d = max(d, 0.0);
Point p1 = (p - c.p) * (c.r * c.r / x);
Point p2 = rotate90((p - c.p) * (-c.r * sqrt(d) / x));
vector<Point> res;
res.push_back(c.p + p1 - p2);
res.push_back(c.p + p1 + p2);
return res;
}
bool isIntersectSP(const Segment &s, const Point &p)
{
return (ccw(s.s, s.t, p) == ON_SEGMENT);
}
Point projection(const Segment &s, const Point &p)
{
Point b = s.t - s.s;
double t = dot(p - s.s, b) / norm(b);
return s.s + b * t;
}
double distanceSP(const Segment &s, const Point &p)
{
Point r = projection(s, p);
if (isIntersectSP(s, r)) return abs(r - p);
return min(abs(s.s - p), abs(s.t - p));
}
bool isIntersectCS(const Circle &c, const Segment &l)
{
double d = distanceSP(l, c.p);
return (d < c.r - EPS);
}
struct edge {
int to, cap, rev;
double cost;
edge(int to, int cap, int rev, double cost) :
to(to), cap(cap), rev(rev), cost(cost) {}
};
int V, prevv[MAX_V], preve[MAX_V];
double h[MAX_V], dst[MAX_V];
vector<edge> G[MAX_V];
void add_edge(int from, int to, int cap, double cost)
{
G[from].push_back(edge(to, cap, G[to].size(), cost));
G[to].push_back(edge(from, 0, G[from].size()-1, -cost));
}
double min_cost_flow(int s, int t, int f)
{
double res = 0;
fill(h, h+V, 0);
while (f > 0) {
priority_queue<P, vector<P>, greater<P> > Q;
fill(dst, dst+V, INF);
dst[s] = 0; Q.push(P(0, s));
while (!Q.empty()) {
P p = Q.top(); Q.pop();
int v = p.second;
if (dst[v] < p.first) continue;
for (int i = 0; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dst[e.to] > dst[v] + e.cost + h[v] - h[e.to] + EPS) {
dst[e.to] = dst[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v; preve[e.to] = i;
Q.push(P(dst[e.to], e.to));
}
}
}
if (dst[t] == INF) return -1;
for (int v = 0; v < V; v++) {
h[v] += dst[v];
}
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int main()
{
int N;
vector<Circle> c(2);
cin >> N;
for (int i = 0; i < 2; i++) {
cin >> c[i].p.x >> c[i].p.y >> c[i].r;
}
vector<Point> r(N), b(N);
for (int i = 0; i < N; i++) {
cin >> r[i].x >> r[i].y;
}
for (int i = 0; i < N; i++) {
cin >> b[i].x >> b[i].y;
}
int S = N * 2, T = S + 1;
V = N * 2 + 2;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
Segment s(r[i], b[j]);
double d = INF;
if (!isIntersectCS(c[0], s) && !isIntersectCS(c[1], s)) {
d = min(d, dist(r[i], b[j]));
}
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
vector<Point> vp1 = tangentCP(c[k], r[i]);
vector<Point> vp2 = tangentCP(c[l], b[j]);
for (int m = 0; m < (int)vp1.size(); m++) {
for (int n = 0; n < (int)vp2.size(); n++) {
Line l1(r[i], vp1[m]), l2(b[j], vp2[n]);
if (r[i] == vp1[m]) {
Point p1 = vp1[m] - c[k].p;
l1.t = vp1[m] + rotate90(p1);
}
if (b[j] == vp2[n]) {
Point p2 = vp2[n] - c[l].p;
l2.t = vp2[n] + rotate90(p2);
}
if (isIntersectLL(l1, l2)) {
Point cp = crosspointLL(l1, l2);
Segment s1(r[i], cp), s2(b[j], cp);
if (!isIntersectCS(c[k], s1) &&
!isIntersectCS(c[l], s2) &&
!isIntersectCS(c[1-k], s1) &&
!isIntersectCS(c[1-l], s2)) {
d = min(d, dist(r[i], cp) + dist(b[j], cp));
}
}
}
}
}
}
if (d != INF) add_edge(i, j + N, 1, d);
}
}
for (int i = 0; i < N; i++) {
add_edge(S, i, 1, 0);
add_edge(i + N, T, 1, 0);
}
double res = min_cost_flow(S, T, N);
if (res == -1) {
cout << "Impossible" << endl;
} else {
printf("%.10f\n", res);
}
return 0;
} |
#include<cstdio>
#include<numeric>
#include<algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
const int V_MAX=109;
const int E_MAX=1000;
template<class T>
struct graph{
int n,m,head[V_MAX],next[2*E_MAX],to[2*E_MAX];
T capa[2*E_MAX],flow[2*E_MAX];
void init(int N){
n=N;
m=0;
rep(u,n) head[u]=-1;
}
void add_directed_edge(int u,int v,T ca){
next[m]=head[u]; head[u]=m; to[m]=v; capa[m]=ca; flow[m]=0; m++;
next[m]=head[v]; head[v]=m; to[m]=u; capa[m]= 0; flow[m]=0; m++;
}
void add_undirected_edge(int u,int v,T ca){
next[m]=head[u]; head[u]=m; to[m]=v; capa[m]=ca; flow[m]=0; m++;
next[m]=head[v]; head[v]=m; to[m]=u; capa[m]=ca; flow[m]=0; m++;
}
};
const ll INF=1LL<<61;
int layer[V_MAX],now[V_MAX];
template<class T>
bool make_layer(const graph<T> &G,int s,int t){
int n=G.n;
rep(u,n) layer[u]=(u==s?0:-1);
int head=0,tail=0;
static int Q[V_MAX]; Q[tail++]=s;
while(head<tail && layer[t]==-1){
int u=Q[head++];
for(int e=G.head[u];e!=-1;e=G.next[e]){
int v=G.to[e];
T capa=G.capa[e],flow=G.flow[e];
if(capa-flow>0 && layer[v]==-1){
layer[v]=layer[u]+1;
Q[tail++]=v;
}
}
}
return layer[t]!=-1;
}
template<class T>
T augment(graph<T> &G,int u,int t,T water){
if(u==t) return water;
for(int &e=now[u];e!=-1;e=G.next[e]){
int v=G.to[e];
T capa=G.capa[e],flow=G.flow[e];
if(capa-flow>0 && layer[v]>layer[u]){
T w=augment(G,v,t,min(water,capa-flow));
if(w>0){
G.flow[ e ]+=w;
G.flow[e^1]-=w;
return w;
}
}
}
return 0;
}
template<class T>
T Dinic(graph<T> &G,int s,int t){
int n=G.n;
T ans=0;
while(make_layer(G,s,t)){
rep(u,n) now[u]=G.head[u];
for(T water=1;water>0;ans+=water) water=augment(G,s,t,INF);
}
return ans;
}
int main(){
int n;
for(ll W;scanf("%d%lld",&n,&W),n;){
bool aki[100][7]={};
ll need[100];
rep(i,n){
int m; scanf("%lld%d",need+i,&m);
rep(j,m){
char s[16]; scanf("%s",s);
if(s[0]=='S' && s[1]=='u') aki[i][0]=true;
if(s[0]=='M') aki[i][1]=true;
if(s[0]=='T' && s[1]=='u') aki[i][2]=true;
if(s[0]=='W') aki[i][3]=true;
if(s[0]=='T' && s[1]=='h') aki[i][4]=true;
if(s[0]=='F') aki[i][5]=true;
if(s[0]=='S' && s[1]=='a') aki[i][6]=true;
}
}
int s=n+7,t=s+1;
graph<ll> G;
G.init(n+9);
// source -> left nodes
rep(u,7) G.add_directed_edge(s,u,W);
// right nodes -> sink
rep(i,n){
int v=7+i;
G.add_directed_edge(v,t,need[i]);
}
// left nodes -> right nodes
rep(i,n) rep(j,7) if(aki[i][j]) {
int u=j,v=7+i;
G.add_directed_edge(u,v,W);
}
puts(Dinic(G,s,t)==accumulate(need,need+n,0LL)?"Yes":"No");
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define MAX_V 150
#define INF (1LL<<55)
typedef long long ll;
struct Edge {
int to;
ll cap, rev;
Edge(int to, ll cap, ll rev) :
to(to), cap(cap), rev(rev) {}
};
vector<Edge> G[MAX_V];
ll level[MAX_V], iter[MAX_V];
void add_edge(int from, int to, ll cap)
{
G[from].push_back(Edge(to, cap, G[to].size()));
G[to].push_back(Edge(from, 0, G[from].size()-1));
}
void bfs(ll s)
{
memset(level, -1, sizeof(level));
queue<ll> Q;
level[s] = 0;
Q.push(s);
while (!Q.empty()) {
ll v = Q.front(); Q.pop();
for (int i = 0; i < (int)G[v].size(); i++) {
Edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
Q.push(e.to);
}
}
}
}
ll dfs(int v, int t, ll f)
{
if (v == t) return f;
for (ll &i = iter[v]; i < (int)G[v].size(); i++) {
Edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
ll d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(int s, int t)
{
ll flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0) return flow;
memset(iter, 0, sizeof(iter));
ll f;
while ((f = dfs(s, t, INF)) > 0) {
flow += f;
}
}
}
void init()
{
for (int i = 0; i < MAX_V; i++) {
G[i].clear();
}
}
int main()
{
ll N, W;
string in;
map<string, int> mp = {
{"Monday", 0},
{"Tuesday", 1},
{"Wednesday", 2},
{"Thursday", 3},
{"Friday", 4},
{"Saturday", 5},
{"Sunday", 6}
};
while (cin >> N >> W, N) {
init();
ll t, c, sum = 0;
int S = N + 7, T = S + 1;
for (int i = 0; i < N; i++) {
cin >> t >> c;
sum += t;
add_edge(S, i, t);
for (int j = 0; j < c; j++) {
cin >> in;
add_edge(i, N + mp[in], INF);
}
}
for (int i = 0; i < 7; i++) {
add_edge(N + i, T, W);
}
cout << (max_flow(S, T) >= sum ? "Yes" : "No") << endl;
}
return 0;
} |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <cmath>
#include <cassert>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <numeric>
#include <complex>
#include <list>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <utility>
#include <functional>
#include <iterator>
#include <unordered_map>
using namespace std;
#define dump(n) cerr<<"# "<<#n<<"="<<(n)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define iter(c) __typeof__((c).begin())
#define foreach(i,c) for(iter(c) i=(c).begin();i!=(c).end();++i)
#define all(c) (c).begin(),(c).end()
#define mp make_pair
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
typedef pair<int,int> pii;
const int INFTY=1<<29;
struct Edge{
int src,dst;
ll flow,capacity;
int next;
Edge(){}
Edge(int s,int d,ll f,ll c,int n):src(s),dst(d),flow(f),capacity(c),next(n){}
};
void AddEdge(vector<Edge>& es,vi& head,int src,int dst,ll flow,ll capacity){
es.push_back(Edge(src,dst,flow,capacity,head[src]));
head[src]=es.size()-1;
}
vi BFS(const vector<Edge>& es,const vi& head,int begin)
{
int size=head.size();
vi label(size,size);
queue<pii> q;
q.push(mp(begin,0));
while(q.size()){
pii cur=q.front(); q.pop();
if(label[cur.first]<=cur.second)
continue;
label[cur.first]=cur.second;
for(int i=head[cur.first];i!=-1;i=es[i].next)
if(es[i].capacity-es[i].flow>0)
q.push(mp(es[i].dst,cur.second+1));
}
return label;
}
ll DFS(vector<Edge>& es,vi& head,int v,int end,const vi& label,ll f)
{
if(v==end)
return f;
for(int& i=head[v];i!=-1;i=es[i].next){
Edge& e=es[i];
if(label[e.src]>=label[e.dst])
continue;
ll residue=e.capacity-e.flow;
if(residue<=0)
continue;
ll augment=DFS(es,head,e.dst,end,label,min(residue,f));
if(augment>0){
e.flow+=augment;
es[i^1].flow-=augment;
return augment;
}
}
return 0;
}
ll Dinic(vector<Edge>& es,const vi& head,int begin,int end)
{
int size=head.size();
for(;;){
vi label=BFS(es,head,begin);
if(label[end]==size)
break;
vi temp=head;
while(DFS(es,temp,begin,end,label,INFTY))
;
}
ll res=0;
for(int i=head[begin];i!=-1;i=es[i].next)
res+=es[i].flow;
return res;
}
int main()
{
unordered_map<string,int> dtoi;
for(string d:{"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"})
dtoi.insert(mp(d,dtoi.size()));
for(ll n,w;cin>>n>>w,n|w;){
vector<Edge> es;
vi head(7+n+2,-1); // 0..6:曜日, 7..7+n-1:生徒, 7+n:src, 7+n+1:snk
int src=7+n,snk=src+1;
rep(i,7){
AddEdge(es,head,src,i,0,w);
AddEdge(es,head,i,src,0,0);
}
ll sum=0;
rep(i,n){
ll t,c; cin>>t>>c;
sum+=t;
rep(j,c){
string s; cin>>s;
AddEdge(es,head,dtoi[s],7+i,0,w);
AddEdge(es,head,7+i,dtoi[s],0,0);
}
AddEdge(es,head,7+i,snk,0,t);
AddEdge(es,head,snk,7+i,0,0);
}
if(Dinic(es,head,src,snk)==sum)
puts("Yes");
else
puts("No");
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
// (?????????,??????,??????)
struct edge{ int to; ll cap; int rev; };
const int MAX_V = 110; // TODO:initialize
const ll F_INF = 12345678901234LL; // TODO:initialize
vector<edge> G[MAX_V];
int level[MAX_V]; // s??????????????¢
int iter[MAX_V]; // ???????????§??????????????£??????
void add_edge(int from, int to, ll cap){
G[from].pb({to,cap,(int)G[to].size()});
G[to].pb({from,0,(int)G[from].size()-1});
}
void dinic_bfs(int s){
memset(level,-1,sizeof(level));
queue<int> que;
level[s]=0;
que.push(s);
while(!que.empty()){
int v = que.front();
que.pop();
rep(i,G[v].size()){
edge &e = G[v][i];
if(e.cap>0 && level[e.to]<0){
level[e.to] = level[v]+1;
que.push(e.to);
}
}
}
}
// ?¢?????????????dfs??§??¢???
ll dinic_dfs(int v, int t, ll f){
if(v==t) return f;
for(int &i=iter[v]; i<G[v].size(); ++i){
edge &e=G[v][i];
if(e.cap>0 && level[v]<level[e.to]){
ll d = dinic_dfs(e.to,t,min(f,e.cap));
if(d>0){
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
// s??????t???????????§???
ll max_flow(int s, int t){
ll flow = 0;
while(1){
dinic_bfs(s);
if(level[t]<0) return flow;
memset(iter,0,sizeof(iter));
ll f;
while((f=dinic_dfs(s,t,F_INF))>0) flow+=f;
}
}
int main()
{
vector<string> days({"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"});
map<string,int> d;
rep(i,days.size()) d[days[i]]=i;
int n;
ll w;
while(cin >>n >>w,n)
{
rep(i,MAX_V) G[i].clear();
int S = n+7, T = S+1;
rep(i,7) add_edge(S,i,w);
ll sumt = 0;
rep(i,n)
{
ll t;
int c;
cin >>t >>c;
sumt += t;
add_edge(7+i,T,t);
while(c--)
{
string s;
cin >>s;
add_edge(d[s],7+i,w);
}
}
cout << (max_flow(S,T)==sumt?"Yes":"No") << endl;
}
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
#define int long long
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
template<class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
struct Dinic {
using Flow = int;
struct Edge {
int to, rev;
Flow cap;
Edge() {}
Edge(int to, int rev, Flow cap) :to(to), rev(rev), cap(cap) {}
};
int n;
vector<vector<Edge>> g;
vector<bool> used;
vector<int> level;
vector<int> iter;
Dinic(int n) :n(n), g(n), used(n), level(n), iter(n) {};
void addArc(int from, int to, Flow cap) {
g[from].emplace_back(to, (int)g[to].size(), cap);
g[to].emplace_back(from, (int)g[from].size() - 1, 0);
}
void addEdge(int a, int b, Flow cap) {
g[a].emplace_back(b, (int)g[b].size(), cap);
g[b].emplace_back(a, (int)g[a].size() - 1, cap);
}
Flow maximumFlow(int s, int t) {
Flow total = 0;
while (true) {
levelize(s);
if (level[t] < 0)return total;
fill(iter.begin(), iter.end(), 0);
Flow f;
while (true) {
f = augment(s, t, INF);
if (f == 0)break;
total += f;
}
}
}
Flow augment(int v, int t, Flow f) {
if (v == t)return f;
for (int &i = iter[v]; i < g[v].size(); i++) {
Edge &e = g[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
Flow d = augment(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
void levelize(int s) {
fill(level.begin(), level.end(), -1);
queue<int> q;
level[s] = 0;
q.push(s);
while (q.size()) {
int v = q.front(); q.pop();
for (int i = 0; i < g[v].size(); i++) {
Edge &e = g[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
q.push(e.to);
}
}
}
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int N, W; cin >> N >> W&&N;) {
Dinic dinic(7 + N + 2);
int src = 7 + N, snk = src + 1;
rep(i, 0, 7)
dinic.addArc(src, i, W);
int total = 0;
rep(i, 0, N) {
int t, c; cin >> t >> c;
total += t;
dinic.addArc(7 + i, snk, t);
rep(j, 0, c) {
string s; cin >> s;
if (s == "Sunday")
dinic.addArc(0, 7 + i, W);
else if (s == "Monday")
dinic.addArc(1, 7 + i, W);
else if (s == "Tuesday")
dinic.addArc(2, 7 + i, W);
else if (s == "Wednesday")
dinic.addArc(3, 7 + i, W);
else if (s == "Thursday")
dinic.addArc(4, 7 + i, W);
else if (s == "Friday")
dinic.addArc(5, 7 + i, W);
else if (s == "Saturday")
dinic.addArc(6, 7 + i, W);
}
}
cout << (dinic.maximumFlow(src, snk) == total ? "Yes" : "No") << endl;
}
return 0;
} |
/*
PM 06:18 - 06:53
*/
#include<iostream>
#include<cstdio>
#include<cmath>
#include<vector>
#include<algorithm>
#include<cstring>
#include<string>
#include<cassert>
#include<climits>
#include<queue>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define IINF (INT_MAX)
#define ULLINF (ULLONG_MAX)
#define MAX_V 500
using namespace std;
typedef unsigned long long ull;
// Library - max_flow - begin
int V;
struct edge{
int to,rev;
ull cap;
edge(int to=IINF,ull cap=ULLINF,int rev=IINF):to(to),cap(cap),rev(rev){}
};
vector<edge> G[MAX_V];
int level[MAX_V];
int iter[MAX_V];
void add_edge(int from,int to,ull cap){
G[from].push_back(edge(to,cap,G[to].size()));
G[to].push_back(edge(from,0,G[from].size()-1));
}
void bfs(int s){
memset(level,-1,sizeof(level));
queue<int> que;
que.push(s);
level[s] = 0;
while(!que.empty()){
int v = que.front(); que.pop();
for(int i=0;i<G[v].size();i++){
edge &e = G[v][i];
if(e.cap > 0 && level[e.to] < 0){
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
ull dfs(int v,int t,ull f){
if(v == t)return f;
for(int &i=iter[v];i<G[v].size();i++){
edge &e = G[v][i];
if(e.cap > 0 && level[v] < level[e.to]){
ull d = dfs(e.to,t,min(f,e.cap));
if(d > 0ULL){
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ull max_flow(int s,int t){
ull flow = 0;
for(;;){
bfs(s);
if(level[t] < 0)return flow;
memset(iter,0,sizeof(iter));
ull f;
while( ( f = dfs(s,t,ULLINF) ) > 0ULL ){
flow += f;
}
}
}
// Library - max_flow - end
int N,c;
ull W,t;
string day;
inline int getIndex(const string& a)
{
if(a[0] == 'M')return 1;
if(a[0] == 'F')return 5;
if(a[0] == 'W')return 3;
if(a[0] == 'S')
{
if(a[1] == 'u')return 0;
else return 6;
}
if(a[0] == 'T')
{
if(a[1] == 'u')return 2;
else return 4;
}
}
void init(){
rep(i,V)G[i].clear();
}
int main(){
while(cin >> N >> W,N|W){
int sp = N + 7, gp = N + 8;
ull sum = 0;
V = gp + 1;
init();
for(int i=0;i<N;i++){
cin >> t >> c;
add_edge(sp,i,t);
sum += t;
for(int j=0;j<c;j++){
cin >> day;
int index = getIndex(day);
add_edge(i,N+index,W);
}
}
for(int i=0;i<7;i++){
add_edge(N+i,gp,W);
}
/*
cout << "graph---" <<endl;
rep(i,V)
{
cout << "node = " << i << endl;
rep(j,G[i].size())
{
cout << "( idex =" << G[i][j].to << "," << G[i][j].cap << ") ";
}
cout << endl;
}
*/
ull res = max_flow(sp,gp);
//cout << "res = " << res << endl;
cout << ( ( res == sum ) ? "Yes" : "No" ) << endl;
}
return 0;
} |
#include <iostream>
#include <algorithm>
#include <vector>
#include <unordered_map>
#include <string>
#include <queue>
using namespace std;
class Edge{
public:
int to,rev;
long long cap;
Edge(int to,long long cap,int rev){
this->to=to; this->cap=cap; this->rev=rev;
}
};
const long long INF = 1L<<58;
int V;
vector<vector<Edge> > G;
vector<int> level,iter;
void addEdge(int from,int to,long long cap){
G[from].push_back(Edge(to, cap, G[to].size()));
G[to].push_back(Edge(from, 0, G[from].size()-1));
}
void D_bfs(int s){
fill(begin(level), end(level), -1);
queue<int> que;
level[s] = 0;
que.push(s);
while(!que.empty()){
int v = que.front(); que.pop();
for(const Edge &e:G[v]){
if(e.cap > 0 && level[e.to] < 0){
level[e.to] = level[v]+1;
que.push(e.to);
}
}
}
}
long long D_dfs(int v,int t,long long f){
if(v==t) return f;
for(int &i=iter[v] ; i<G[v].size(); ++i){
Edge &e = G[v][i];
if(e.cap > 0 && level[v] < level[e.to]){
long long d = D_dfs(e.to, t, min(f ,e.cap));
if(d > 0){
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
long long Dinic(int s,int t){
long long flow = 0;
while(true){
D_bfs(s);
if(level[t] < 0) return flow;
fill(begin(iter), end(iter), 0);
long long f=0;
while( (f=D_dfs(s, t, INF)) > 0) flow += f;
}
}
int main(){
int N;
long long W;
unordered_map<string, int> weeks;
for(string s:{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}) weeks.insert(make_pair(s, weeks.size()+1));
while(true){
cin>>N>>W;
if(N==0) break;
V=10+N+1;
level.resize(V,0);
iter.resize(V,0);
G.clear();
G.resize(V,vector<Edge>());
for(int i=1; i<=7; ++i) addEdge(0,i,W);
long long T,sum=0;
int C;
for(int i=0; i<N; ++i){
cin>>T>>C;
sum+=T;
for(int j=0; j<C; ++j){
string week;
cin>>week;
addEdge(weeks[week], 10+i, min(T,W));
}
addEdge(10+i, 10+N, T);
}
long long ret = Dinic(0,10+N);
cout << (ret>=sum? "Yes": "No") << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
constexpr long long Inf = numeric_limits<long long>::max() / 4;
namespace flow_algorithm
{
template<class Flow>
struct edge
{
int to;
Flow cap, rev;
};
/*
template<class Flow>
using edges = vector<edge<Flow>>;
template<class Flow>
using graph = vector<edges<Flow>>;
*/
typedef vector<edge<long long>> edges;
typedef vector<edges> graph;
template<class Flow>
class dinic
{
private:
int V;
// graph<Flow> g;
graph g;
vector<int> level;
vector<int> iter;
public:
// Flow static constexpr Inf = numeric_limits<Flow>::max() / 4;
private:
void bfs(int s)
{
rep(i, V) level[i] = -1;
queue<int> q;
q.push(s);
level[s] = 0;
while(!q.empty()) {
int curr = q.front(); q.pop();
rep(i, g[curr].size()) {
edge<Flow>& e = g[curr][i];
if(level[e.to] != -1) { continue; }
if(e.cap <= 0) { continue; }
level[e.to] = level[curr] + 1;
q.push(e.to);
}
}
}
Flow dfs(int curr, int tar, Flow flow)
{
if(curr == tar) { return flow; }
for(int &i = iter[curr]; i<(int)g[curr].size(); i++) {
edge<Flow>& e = g[curr][i];
if(e.cap <= 0) { continue; }
if(level[curr] >= level[e.to]) { continue; }
Flow d = dfs(e.to, tar, min(flow, e.cap));
if(d <= 0) { continue; }
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
return 0;
}
public:
dinic(int V_)
{
V = V_;
g.resize(V);
level.resize(V);
iter.resize(V);
}
void add_edge(int from, int to, Flow cap)
{
g[from].push_back({to, cap, (Flow)g[to].size()});
g[to].push_back({from, 0, (Flow)g[from].size()-1});
}
Flow max_flow(int src, int dest)
{
Flow flow = 0;
for(;;) {
bfs(src);
if(level[dest] < 0) { return flow; }
rep(i, V) iter[i] = 0;
Flow f;
while((f = dfs(src, dest, Inf)) > 0) {
flow += f;
}
}
}
};
}
typedef long long ll;
int const SBASE = 10;
int const SRC = 150, SINK = 151;
int main() {
map<string, int> mp = {
{"Monday",0},
{"Tuesday", 1},
{"Wednesday", 2},
{"Thursday", 3},
{"Friday", 4},
{"Saturday", 5},
{"Sunday", 6}
};
int N; ll W;
while(cin >> N >> W && (N|W)) {
flow_algorithm::dinic<ll> dn(200);
rep(i, 7) dn.add_edge(SRC, i, W);
ll need = 0;
rep(i, N) {
ll t; int c; cin >> t >> c;
need += t;
rep(j, c) {
string s; cin >> s;
// dn.add_edge(mp[s], SBASE+i, flow_algorithm::dinic<ll>::Inf);
dn.add_edge(mp[s], SBASE+i, Inf);
}
dn.add_edge(SBASE+i, SINK, t);
}
cout << ( dn.max_flow(SRC, SINK) == need ? "Yes" : "No" ) << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define MAX_V 514
#define INF (1LL<<58)
typedef long long ll;
struct Edge {
ll to, cap, rev;
Edge(ll to, ll cap, ll rev) :
to(to), cap(cap), rev(rev) {}
};
vector<Edge> G[MAX_V];
ll level[MAX_V], iter[MAX_V];
void add_edge(int from, int to, ll cap)
{
G[from].push_back(Edge(to, cap, G[to].size()));
G[to].push_back(Edge(from, 0, G[from].size()-1));
}
void bfs(int s)
{
memset(level, -1, sizeof(level));
queue<int> Q;
level[s] = 0;
Q.push(s);
while (!Q.empty()) {
int v = Q.front(); Q.pop();
for (int i = 0; i < (int)G[v].size(); i++) {
Edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
Q.push(e.to);
}
}
}
}
ll dfs(int v, int t, ll f)
{
if (v == t) return f;
for (ll &i = iter[v]; i < (ll)G[v].size(); i++) {
Edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
ll d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(int s, int t)
{
ll flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0) return flow;
memset(iter, 0, sizeof(iter));
ll f;
while ((f = dfs(s, t, INF)) > 0) {
flow += f;
}
}
}
void init()
{
for (ll i = 0; i < MAX_V; i++) {
G[i].clear();
}
}
int main()
{
map<string, int> w = {
{"Monday", 0},
{"Tuesday", 1},
{"Wednesday", 2},
{"Thursday", 3},
{"Friday", 4},
{"Saturday", 5},
{"Sunday", 6}
};
ll N, W;
while (cin >> N >> W, N) {
init();
ll t, c, sum = 0;
int S = N + 7, T = S + 1;
for (int i = 0; i < N; i++) {
cin >> t >> c;
sum += t;
add_edge(S, i, t);
for (int j = 0; j < c; j++) {
string s;
cin >> s;
add_edge(i, N + w[s], INF);
}
}
for (int i = 0; i < 7; i++) {
add_edge(N + i, T, W);
}
if (sum > 7*W) {
cout << "No" << endl;
continue;
}
cout << (max_flow(S, T) >= sum ? "Yes" : "No") << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct edge{ int to,rev; ll cap; };
vector< vector<edge> > G(110);
bool used[110];
#define INF (1LL << 55)
void addEdge(int from, int to, ll cap)
{
G[from].push_back((edge){to, (int)G[to].size(), cap});
G[to].push_back((edge){from, (int)G[from].size()-1, 0});
}
ll dfs(int v, int t, ll f)
{
if(v == t) return f;
used[v] = true;
for(int i = 0; i < G[v].size(); i++){
edge &e = G[v][i];
if(!used[e.to] && e.cap > 0){
ll d = dfs(e.to, t, min(f, e.cap));
if(d > 0){
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll maxFlow(int s, int t)
{
ll flow = 0;
for(;;){
memset(used, false, sizeof(used));
ll f = dfs(s, t, INF);
if(f == 0) return flow;
flow += f;
}
}
int main()
{
map<string, int> days = {
{"Sunday",0},
{"Monday",1},
{"Tuesday",2},
{"Wednesday",3},
{"Thursday",4},
{"Friday",5},
{"Saturday",6}
};
ll N, W;
while(cin >> N >> W, N || W){
G.clear(); G.resize(N + 9);
int S = N + 7, T = S + 1;
ll lesson = 0;
for(int i = 0; i < N; i++){
ll t; int c;
cin >> t >> c;
lesson += t;
addEdge(S, i, t);
for(int j = 0; j < c; j++){
string day;
cin >> day;
addEdge(i, N + days[day], INF);
}
}
for(int i = 0; i < 7; i++){
addEdge(N + i, T, W);
}
cout << (maxFlow(S, T) >= lesson ? "Yes":"No") << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef ll Weight;
typedef ll Capacity;
struct Edge {
int src, dst; Capacity cap;
Edge(int s, int d, Capacity c) : src(s), dst(d), cap(c) {}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
struct Dinic {
int n, s, t;
vector<int> level, prog, que;
vector<vector<Capacity> > cap, flow;
vector<vector<int> > g;
Capacity inf;
Dinic() {}
Dinic(const Graph &graph)
: n(graph.size()),
cap(n, vector<Capacity>(n)), flow(n, vector<Capacity>(n)),
g(n, vector<int>()), inf((int)1e9) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < graph[i].size(); j++) {
const Edge& e = graph[i][j];
int u = e.src, v = e.dst;
Capacity c = e.cap;
add_edge(u, v, c);
}
}
}
Dinic(int n_) : n(n_), cap(n, vector<Capacity>(n)), flow(n, vector<Capacity>(n)),
g(n, vector<int>()), inf((int)1e9) {
}
void add_edge(int u, int v, Capacity c) {
cap[u][v] += c; cap[v][u] += c; flow[v][u] += c;
g[u].push_back(v); g[v].push_back(u);
}
void reset() {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
cap[i][j] = flow[i][j] = 0;
}
g[i].clear();
}
}
inline Capacity residue(int u, int v) { return cap[u][v] - flow[u][v]; }
Capacity solve(int s_, int t_) {
this->t = t_, this->s = s_;
que.resize(n + 1);
Capacity res = 0;
while(levelize()) { prog.assign(n, 0); res += augment(s, inf); }
return res;
}
bool levelize() {
int l = 0, r = 0;
level.assign(n, -1); level[s] = 0; que[r++] = s;
while(l != r) {
int v = que[l++]; if(v == t) break;
for(int i = 0; i < g[v].size(); i++) {
const int& d = g[v][i];
if(level[d] == -1 && residue(v, d) != 0) {
level[d] = level[v] + 1; que[r++] = d;
}
}
}
return level[t] != -1;
}
Capacity augment(int v, Capacity lim) {
Capacity res = 0;
if(v == t) return lim;
for(int &i = prog[v]; i < (int)g[v].size(); i++) {
const int &d = g[v][i];
if(residue(v, d) == 0 || level[v] >= level[d]) continue;
const Capacity aug = augment(d, min(lim, residue(v, d)));
flow[v][d] += aug; flow[d][v] -= aug;
res += aug; lim -= aug;
if(lim == 0) break;
}
return res;
}
};
string day[7] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, W;
while(cin >> N >> W, N + W) {
Dinic D(N + 7 + 2);
int S = N + 7, T = S + 1;
ll tsum = 0;
for(int i = 0; i < N; i++) {
ll t, c;
cin >> t >> c;
tsum += t;
for(int j = 0; j < c; j++) {
string s;
cin >> s;
int idx = find(day, day + 7, s) - day;
//cout << idx << endl;
D.add_edge(i, N + idx, t);
}
D.add_edge(S, i, t);
}
for(int i = 0; i < 7; i++) {
D.add_edge(N + i, T, W);
}
if(tsum == D.solve(S, T)) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
} |
#include <cstdio>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
const long long INF = LLONG_MAX / 4;
class Edge
{
public:
int to, rev;
long long cap;
Edge(){};
Edge(int to0, long long cap0){to = to0; cap = cap0;}
Edge(int to0, long long cap0, int rev0){to = to0; cap = cap0; rev = rev0;}
};
long long maxFlow(const vector<vector<Edge> >& edges0, int source, int sink)
{
static vector<vector<Edge> > edges;
static vector<unsigned> index;
static vector<int> level;
static int n;
class Func{
public:
static void bfs(int s){
level.assign(n, -1);
queue<int> q;
level[s] = 0;
q.push(s);
while(!q.empty()){
int v = q.front();
q.pop();
for(unsigned i=0; i<edges[v].size(); ++i){
Edge& e = edges[v][i];
if(e.cap > 0 && level[e.to] < 0){
level[e.to] = level[v] + 1;
q.push(e.to);
}
}
}
}
static long long dfs(int s, int t, long long f){
if(s == t)
return f;
for(unsigned& i=index[s]; i<edges[s].size(); ++i){
Edge& e = edges[s][i];
if(e.cap > 0 && level[s] < level[e.to]){
long long g = dfs(e.to, t, min(f, e.cap));
if(g > 0){
e.cap -= g;
edges[e.to][e.rev].cap += g;
return g;
}
}
}
return 0;
}
};
n = edges0.size();
edges.assign(n, vector<Edge>());
for(int i=0; i<n; ++i){
for(unsigned j=0; j<edges0[i].size(); ++j){
const Edge& e = edges0[i][j];
edges[i].push_back(Edge(e.to, e.cap, edges[e.to].size()));
edges[e.to].push_back(Edge(i, 0, edges[i].size()-1));
}
}
long long ret = 0;
for(;;){
Func::bfs(source);
if(level[sink] < 0)
return ret;
index.assign(n, 0);
long long f;
while((f = Func::dfs(source, sink, INT_MAX)) > 0)
ret += f;
}
return 0;
}
int main()
{
map<string, int> index;
index["Monday"] = 1;
index["Tuesday"] = 2;
index["Wednesday"] = 3;
index["Thursday"] = 4;
index["Friday"] = 5;
index["Saturday"] = 6;
index["Sunday"] = 7;
for(;;){
int n;
long long w;
cin >> n >> w;
if(n == 0)
return 0;
long long sum = 0;
vector<vector<Edge> > edges(n+9);
for(int i=1; i<=7; ++i)
edges[0].push_back(Edge(i, w));
for(int i=0; i<n; ++i){
long long t;
int c;
cin >> t >> c;
sum += t;
for(int j=0; j<c; ++j){
string s;
cin >> s;
edges[index[s]].push_back(Edge(i+8, INF));
}
edges[i+8].push_back(Edge(n+8, t));
}
if(maxFlow(edges, 0, n+8) == sum)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
} |
#include <iostream>
#include <vector>
#include <map>
#include <cstring>
#include <climits>
using namespace std;
typedef long long ll;
#define MAX_V 1000
#define INF 100000000000LL
ll V;
ll cap[MAX_V][MAX_V];
bool used[MAX_V];
ll dfs(ll v, ll g, ll f){
if(v == g) return f;
used[v] = true;
for(ll i = 0; i < V; i++){
ll c = cap[v][i];
if(!used[i] && c > 0){
ll d = dfs(i, g, min(f, c));
if(d > 0){
cap[v][i] -= d;
cap[i][v] += d;
return d;
}
}
}
return 0;
}
ll mf(ll s, ll g){
ll flow = 0;
for(;;){
memset(used, 0, sizeof(used));
ll f = dfs(s, g, INF);
if(f == 0) return flow;
flow += f;
}
}
void add_edge(ll from, ll to, ll c){
cap[from][to] = c;
cap[to][from] = 0;
}
int main(){
ll n, w;
map<string,int> week;
week["Sunday"] = 0;
week["Monday"] = 1;
week["Tuesday"] = 2;
week["Wednesday"] = 3;
week["Thursday"] = 4;
week["Friday"] = 5;
week["Saturday"] = 6;
while(cin >> n >> w, n || w){
memset(cap, -1, sizeof(cap));
for(ll i = 0; i < 7; i++){
add_edge(0, i + 1, w);
}
ll sum = 0;
for(ll i = 0; i < n; i++){
ll tn, cn;
cin >> tn >> cn;
add_edge(i + 8, n + 8, tn);
sum += tn;
for(ll j = 0; j < cn; j++){
string s;
cin >> s;
ll from = week[s] + 1;
add_edge(from, i + 8, w);
}
}
V = n + 9;
ll flow = mf(0, V - 1);
if(flow == sum){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.