题目均来自LeetCode

242. Valid Anagram

 这题按照上一篇《简单的查找问题》中提到的那样通过map进行映射标记，循环

遍历判断一下即可。

class Solution {
public:
    bool isAnagram(string s, string t) {
       if(s.size() != t.size())
		return false;
	map<char,int> s1;
	for( int i = 0 ; i < s.size() ; i++ ) {
		s1[s[i]] ++;
	}
	
	bool isA = true;
	for( int i = 0 ; i < t.size() ; i++ ) {
		if( s1[t[i]] > 0 ) {
			s1[t[i]] --;
		}else {
			isA = false;
			break;
		}
	}
	return isA; 
    }
};

202
. 
Happy Number

在这里我仍然使用map作为标记，而且我将一个int类型的整数变为string类型进行存储，这样方便进行取出来每一位。

bool isAnHappyNumber(int n) {
	map<string,int> list;
	int sum;
	stringstream ss;
	ss<<n;
	string tem = ss.str();  // int类型转换成string类型
	do {
		sum = 0;
		list[tem] ++;
		for( int i = 0 ; i < tem.size() ; i++ ) {
			sum += pow(tem[i]-48 ,2);// string取出来每一位都是一个字符，根据ASCII码规则进行转换
		}
		if( sum == 1)  {
			return true;
		}
		ss.str("");   //如果想继续使用的话需要将ss里面清空
		ss<< sum;
		tem = ss.str();
	}while(list[tem] == 0);
	return false;
}

补充：c++中int 类型与string类型之间的转换挺恶心的，我这里面采用stringstream进行转化的，别忘了添加头文件。当然也可以通过char数组作为媒介，string可以通过 c_str()方法转换成字符数组。另外string类型通过下标可以访问到每一位字符，每一个字符都是char类型，如果直接运算的话，会把char类型转换成相对应的ASCII码，我们可以根据ASCII码表的一些规则进行一系列的转换。在这里字符0的ASCII的码为48，所以减去48就可以得到对应的数值了。当然在这里我们可以在这里存储int类型的数据，而不是string类型的数据，通过取余来求出每一位，代码如下：

 void getSum(int n) { int sum; while(n) { sum += pow(n%10,2); n = n/10; } }

205. Isomorphic Strings   290. Word Pattern

  这两个题的类型很相似，解决方案是也差不多。

 290给你一个字符串和模式，判断这个字符串是否符合这个模式。

 205 给你两个字符串判断他们是否是同构的，也就是说能够相互映射。

这里这我使用了map作为查询表，标记的是字符或字符串 所对应的类型

vector 存放位置以及对应的类型。（以上都是在c++98中实现的，如果使用c++11， 提可以使用unordered_map，就不需要使用vector了，这这里因为map是无序的，需要确定每个位置上所对应的不同类型，因此多创建了一个vector）

思路就是取出来字符或者字符串去map中查询，如果存在就取所对应的类型，存放到

vector对应的位置中去，如果在map中没有查询到，就创建一个存储到map中，并存放到vector中去，最后通过比较，vector中不同位置的类型是否相同而确定两个字符串是否是同构或者是符合某个模式。

以下是具体代码：

290

代码可能写的有点囉嗦，还有很大的优化空间，有兴趣的朋友可以进行优化一下

bool wordPattern(string pattern, string str) {
	map<string,int> m; // require table (itself and type)
	vector<int> v,v1;  //  result table  (local and type)
	vector<string> s_list;
	string tem("");
	// 这里是通过空字符进行字符串的截取
	for(int i = 0 ; i < str.size() ; i++ ) {
		if(str[i] == ' ') {
			s_list.push_back(tem);
			tem = "";
		} 
		else 
			tem += str[i];	
	}
	s_list.push_back(tem);
	if(s_list.size() != pattern.size())
		return false;
	map<string,int>::iterator it;
	int type = 0;
	for( int i = 0 ; i < pattern.size() ; i++ ) {
		it = m.find(pattern[i] + "");
		if(it != m.end()) {
			v.push_back(it->second);
		}else {
			v.push_back(++type);
			m[pattern[i] +""] = type;
		}
	}

	m.clear();
	type = 0;
	for( int i = 0 ; i < s_list.size() ; i++ ) {
		it = m.find(s_list[i]);
		if(it != m.end()) {
			v1.push_back(it->second);
		}else {
			v1.push_back(++type);
			m[s_list[i]] = type;
		}
	}
	for(int i = 0 ; i < v.size() ; i++ ) {
		if(v[i] != v1[i])
			return false;
	}
	return true;
	
}

205代码如下：

bool isIsomorphic(string s, string t) {
	if( s.size() != t.size() )
		return false;
        vector<int> v;
        vector<int> v1;
        map<char,int> m;
        int type = 0;
        map<const char,int>::iterator it;
        for( int i = 0 ; i < s.size() ; i++ ) {
        	it = m.find(s[i]);
        	if( it != m.end() )
        		v.push_back(it->second);
        	else {
        		v.push_back(++type);
        		m[s[i]] = type;
			}		
		}
		m.clear();
		type = 0;
		for( int i = 0 ; i < t.size() ; i++ ) {
        	it = m.find(t[i]);
        	if( it != m.end() )
        		v1.push_back(it->second);
        	else {
        		v1.push_back(++type);
        		m[t[i]] = type;
			}
			if(v1[i] != v[i])
				return false;		
		}
		return true;
}