vvb parse_obstacles(const vs &initial_map) {
vvb obstacles(initial_map.size()+2, vector<bool>(initial_map[0].size()+2, true));
for (int i = 0; i < initial_map.size(); i++) {
for (int j = 0; j < initial_map[i].size(); j++) {
obstacles[i+1][j+1] = (initial_map[i][j] == '*');
}
}
return obstacles;
}
void print(vs v){
int n=v.size();
for(int i=0;i<n; i++){
cout<<v[i]<<endl;
}
cout<<n;
}
void solve(vs names,vs towns)
{
int n=names.size();
vs res(n);
map<string,int> f;
rep(i,n){
res[i]=shorten(names[i],towns[i]);
f[res[i]]++;
}
pii find_king(const vs &initial_map) {
for (int i = 0; i < initial_map.size(); i++) {
for (int j = 0; j < initial_map[i].size(); j++) {
if (initial_map[i][j] == 'X') {
return make_pair(i+1, j+1);
}
}
}
// never reaches
}
/*
* Returns an integer which is the index
* of a string in a vector of strings
*/
int returnIndexOfVector(vs &stringVector, string value)
{
int iii;
for (iii = 0; iii < stringVector.size(); iii++) {
if (stringVector[iii] == value) {
return iii;
}
}
return -1;
}
string fill(vs ss)
{
int p=ss.size();
string res;
for(int i=0;i/p<ss[i%p].size();i++){
char c=ss[i%p][i/p];
res+=c=='.'?'0':c;
}
return res;
}
string solve_naive(vs ss)
{
int k=ss.size(),n=ss[0].size();
rep(i,k){
string s=ss[0]; sort(all(s));
string t=ss[i]; sort(all(t));
if(s!=t)
return "-1";
}
void work(map<vi, int> & ans, vs & s)
{
int n = s.size(), m = s[0].size();
rep(x, t[m])
{
vi key(n);
rep(i, n) rep(j, m)
key[i] += x / t[j] % 10 + '0' == s[i][j];
auto p = ans.find(key);
if(p == ans.end()) ans[key] = x;
else p->second = -1;
}
int solve(int apos,int wpos,int k)
{
if(apos==a.size() && wpos==w.size()-1 && k) return 1;
if(apos==a.size() || wpos==w.size()) return 0;
int& res=dp[apos][wpos][k];
if(res!=-1) return res;
res=0;
for(int i=k;i<w[wpos].size();i++)
if(a[apos]==w[wpos][i]) res+=solve(apos+1,wpos,i+1);
if(k) res+=solve(apos,wpos+1,0);
return res;
}
void printCase(vs V, vvs A, vd f){
printf("Case Details:\n");
printf("--------------\n");
printf("Number Of Variables n: %d\n\n", V.size());
printf("Rules:\n");
printf("-------\n");
for(int i=0; i<A.size(); i++){
for(int j=0; j<A[i].size(); j++){
printf("%s ", A[i][j].c_str());
}
printf(":: %.3lf\n", f[i]);
}
}
string makeMatch(vs namesWomen, vs answersWomen, vs namesMen, vs answersMen, string queryWoman)
{
vp women;
vp men;
int size = namesWomen.size();
for(int i = 0; i<size; i++)
{
women.push_back(ps(namesWomen[i], answersWomen[i]));
men.push_back(ps(namesMen[i], answersMen[i]));
}
sort(women.begin(), women.end());
sort(men.begin(), men.end());
int compatible = 0;
vp dates;
for(vp::iterator it = women.begin(); it != women.end(); it++)
{
vp::iterator idealMale;
string wAnswer = it->second;
compatible = -1;
for(vp::iterator mit = men.begin(); mit != men.end(); mit++)
{
string mAnswer = mit->second;
int score = 0;
for(int x = 0; x < wAnswer.length(); x++)
{
if(wAnswer[x] == mAnswer[x])
score++;
}
if(score > compatible)
{
compatible = score;
idealMale = mit;
}
}
if(it->first == queryWoman)
return idealMale->first;
men.erase(idealMale);
}
string noMatch = "NO_MATCH";
return noMatch;
}
void find_openspaces(const vs &initial_map, pii *spaces) {
int count = 0;
for (int i = 0; i < initial_map.size(); i++) {
for (int j = 0; j < initial_map[i].size(); j++) {
if (initial_map[i][j] == '.') {
spaces[count] = make_pair(i+1, j+1);
count++;
if (count == 2) {
return;
}
}
}
}
}
/*
* Outputs the predictions to file
* and returns the accuracy of the classification
*/
double printPredictionsAndCalculateAccuracy(vs &givenData, vs &predictions)
{
ofstream outputFile;
outputFile.open("decisionTreeOutput.txt");
int correct = 0;
outputFile << setw(3) << "#" << setw(16) << "Given Class" << setw(31) << right << "Predicted Class" << endl;
outputFile << "--------------------------------------------------" << endl;
for (int iii = 0; iii < givenData.size(); iii++) {
outputFile << setw(3) << iii + 1 << setw(16) << givenData[iii];
if (givenData[iii] == predictions[iii]) {
correct++;
outputFile << " ------------ ";
}
else {
outputFile << " xxxxxxxxxxxx ";
}
outputFile << predictions[iii] << endl;
}
outputFile << "--------------------------------------------------" << endl;
outputFile << "Total number of instances in test data = " << givenData.size() << endl;
outputFile << "Number of correctly predicted instances = " << correct << endl;
outputFile.close();
return (double)correct / 50 * 100;
}
/*
* function: naive_bayes::classification 对数据进行分类
* return: 该数据最可能的目标属性值
*
*/
std::string naive_bayes::classification(vs& data)
{
assert((int)data.size() == num_attr - 1);
// 为了防止溢出，以下对概率值取了对数
int max_index = -1;
double p_max = -1e300; // 最大概率
vd p_targ_val; // 每个目标属性值对该数据的概率 P(data | target_attr[i])
p_targ_val.resize(num_targ, 0.0);
auto f = [&](double x, double u, double d)
{// 求正态分布概率密度
return std::exp(-(x - u) * (x - u) / (2 * d)) / sqrt(4 * std::acos(-1) * d);
};
for(int i = 0; i < num_targ; ++i)
{
auto& t = p_targ_val[i];
t = std::log(p_target[i]); // 取对数
for(int j = 0; j < num_attr - 1; ++j)
{
auto& p = p_datas[i][j];
if(is_numeric[j])
{
t += std::log(f(std::stod(data[j]), p.mean_value, p.variance));
}
else
{
auto it = attr_to_int[j].find(data[j]);
if(it == attr_to_int[j].end())
{
std::cerr<<"No such attribute value."<<std::endl;
exit(1);
}
t += std::log(p.p_attr[it->second]);
}
}
}
// 找到最大概率值
for(int i = 0; i < num_targ; ++i)
{
// std::cout<<p_targ_val[i]<<std::endl;
if(p_max < p_targ_val[i])
p_max = p_targ_val[i], max_index = i;
}
return int_to_attr[num_attr - 1][max_index];
}
int shortestLadder(vector <string> level, int coinRow, int coinColumn){
M = level;
n = M.size();
m = M[0].size();
vi move(2);
move[0] = -1; move[1] = 1;
for(int l = 0; l < n; l++){
// cout<<"level = "<<l<<endl;
fi(n) fj(m) visited[i][j] = 0;
queue<pi> Q;
Q.push(mp(n-1, m-1));
visited[n-1][m-1] = 1;
while(!Q.empty()){
pi p = Q.front();
Q.pop();
int x = p.first, y = p.second;
// cout<<x<<" "<<y<<endl;
if(x+1 == coinRow && y+1 == coinColumn) return l;
//Move horizontally
for(int k : move){
if(valid(x, y+k)){
Q.push(mp(x, y+k));
visited[x][y+k] = 1;
}
}
//Move vertically
for(int i = 1; i <= l; i++){
for(int k : move){
if(valid(x+k*i, y)){
visited[x+k*i][y] = 1;
Q.push(mp(x+k*i, y));
}
}
}
}
}
}
void print(vs tmp) {
for (int i = 0; i < tmp.size(); ++i)
cout << "\"" << tmp[i] << "\"" << endl;
}
double recur(vs V, vvs A, vd f){
//printCase(V, A, f);
if(V.size()==1) return f[0];
string var = V[0];
int val;
for(int i=0; i<A.size(); i++){
if(A[i].size()>1) continue;
if(var==A[i][0]) {
val = f[i];
break;
}
}
vs Vij = V;
vvs Aij(A.size(), vs());
//step 1
Vij.erase(Vij.begin());
//step 2
for(int i=0; i<A.size(); i++){
for(int j=0; j<A[i].size(); j++){
if(var!=A[i][j]) Aij[i].push_back(A[i][j]);
}
}
// remove empty rules
for(int i=0; i<Aij.size(); i++){
if(Aij[i].size()==0){
Aij.erase(Aij.begin()+i);
i--;
}
}
// remove repeated rules
set<vs> s(Aij.begin(), Aij.end());
Aij.clear();
Aij = vvs(s.begin(), s.end());
// construct DAG
vector<vi> graph(Aij.size(), vi());
vector<vi> graphT(Aij.size(), vi());
for(int i=0; i<Aij.size(); i++){
for(int j=0; j<Aij.size(); j++){
if(i==j||Aij[i].size()>=Aij[j].size()) continue;
bool subset=1;
for(int k=0; k<Aij[i].size()&⊂ k++){
bool found=0;
for(int l=0; l<Aij[j].size(); l++){
if(Aij[i][k]==Aij[j][l]){
found=1;
break;
}
}
subset&=found;
}
if(subset){
graph[i].push_back(j);
graphT[j].push_back(i);
}
}
}
// Try for all values of the number of instances of the cur variable
double maxValue=0;
while(val>0){
vd fij(Aij.size(), INF);
for(int i=0; i<Aij.size(); i++){
vs S = Aij[i];
vs Sv = S;
Sv.push_back(var);
bool foundS=false, foundSv=false;
double foundSval, foundSvVal;
for(int j=0; j<A.size(); j++){
if(S.size()==A[j].size()){
bool sameSet=1;
for(int k=0; k<S.size()&&sameSet; k++){
bool found=0;
for(int l=0; l<S.size(); l++){
if(S[k]==A[j][l]) {
found = 1;
break;
}
}
sameSet&=found;
}
if(sameSet) foundS=true, foundSval=f[j];
}
if(Sv.size()==A[j].size()){
bool sameSet=1;
for(int k=0; k<Sv.size()&&sameSet; k++){
bool found=0;
for(int l=0; l<Sv.size(); l++){
if(Sv[k]==A[j][l]) {
found = 1;
break;
}
}
sameSet&=found;
}
if(sameSet) foundSv=true, foundSvVal=f[j]/val;
}
}
if(!foundSv) fij[i]=foundSval;
else if(!foundS) fij[i]=foundSvVal;
else fij[i]=min(foundSval,foundSvVal);
}
queue<int> q;
for(int i=0; i<Aij.size(); i++){
if(graph[i].size()==0) q.push(i);
}
while(!q.empty()){
int node = q.front(); q.pop();
for(int i=0; i<graph[node].size(); i++){
fij[node]=min(fij[node], fij[graph[node][i]]);
}
for(int i=0; i<graphT[node].size(); i++){
q.push(graphT[node][i]);
}
}
maxValue=max(maxValue, val*recur(Vij, Aij, fij));
val--;
}
return maxValue;
}
template<typename Ch,typename Tr,typename C>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;
int calc(vs ops,vi xs,int a)
{
rep(i,ops.size()){
if(ops[i]=="&") a&=xs[i];
if(ops[i]=="^") a^=xs[i];
if(ops[i]=="|") a|=xs[i];
}
return a;
}
int main()
{
#ifndef _GLIBCXX_DEBUG
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
constexpr char endl='\n';
#endif
