string b[15] = {"ling","yi","er","san","si","wu","liu","qi","ba","jiu"};
//数组记得稍微开大一点，不是坏事，养成这个习惯可以防RE，用得到的int型数据去当下标然后一一对应。

unordered_map<int,string> h;
h.emplace(1,"yi");
.......

bool cmp(t a,t b){//t在这里表示一种数据类型，无论是语言自带的还是自己设计的结构体，我懒得打模板那个单词
   return a<b//这个就表示从小到大排序
   return a>b//这个就表示从大到小排序
}

bool cmp(stu a,stu b){
    return a.gpa>b.gpa;
}

sort(add.begin(),add.end(),cmp);//注意这个begin和end的写法是vector才有的

bool isprime(int a){
    if (a<=1) return false;//这里用这样的写法是更加稳健的，谁都不知道题目会不会输入负数进来
    if (a==2) return true;
    for (int i=2;i*i<a;i++){//这里采用i*i的写法下面讲，这是一个利用数学性质降低时间复杂度。
        if (a%i==0){
            return false;
        }
    }
    return true;
}

......
istringstream iss(s);
    string word;
    vector<string> tokens;

    while (iss >> word) { // 自动以空格、制表符分隔
        tokens.push_back(word);
    }
......

getline(cin,a);//不要cin，cin遇到空格会直接断掉
    vector<string> ans;
    string word;
    for (char c:a){
        if (c==' '){
            if (!word.empty()){
                ans.push_back(word);
                word.clear();
            }
        }else{
            word+=c;
        }
    }
    if (!word.empty()){
        ans.push_back(word);
    }

int r=0,num=0;
    string s,ans;
    for (char c:a){
        num=r*10+(c-'0');
        s+=(num/b)+'0';
        r=num%b;//这个数字是上一轮得到的余数，应该定义在全局。
    }
    int pos=0;
    while (pos<s.size()-1&&s[pos]=='0'){
        pos++;
    }//去除前导0
    ans=s.substr(pos);

#include <bits/stdc++.h>
using namespace std;
#define int long long

int a,b,n,d;
signed main(){
    cin>>a>>b>>d;
    n=a+b;
    vector<int> ans;
    if (n==0){//记得特判
        cout<<0;
        return 0;
    }
    while (n>0){
        ans.push_back(n%d);
        n/=d;
    }
    for (int i=ans.size()-1;i>=0;i--){
        cout<<ans[i];
    }
    return 0;
}

class node{
    public:
    int add,data,next;
};

00100 6 4//第一个是初始节点地址，第二个是节点总个数
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

unordered_map<int,node> a;//这个用于记录地址和节点之间的映射关系

while(beginn!=-1){
        d.push_back(a[beginn]);
        beginn=a[beginn].next;
    }

for (int i=0;i<(int)ans.size();i++){
        if (i!=ans.size()-1){
            ans[i].next=ans[i+1].add;
        }else{
            ans[i].next=-1;
        }
    }
    for (auto &it:ans){
        printf("%05d %d ",it.add,it.data);
        if (it.next != -1)
            printf("%05d\n",it.next);
        else
            printf("-1\n");
    }

#include <bits/stdc++.h>
using namespace std;

int n,score,k;
unordered_map<int,int> hash1;
int main(){
    cin>>n;
    while (n--){
        cin>>score;
        hash1[score]++;
    }
    cin>>k;
    for (int i=1;i<=k;i++){
        int finds;
        cin>>finds;
        if (i==k){
            cout<<hash1[finds];
        }else{
            cout<<hash1[finds]<<" ";
        }
    }
    return 0;
}

while (sum>0){//这里控制一整个循环的进行，sum代表所有符合条件的字符，一旦sum归零，那么循环就该结束
        for (char c:res){//res就是目标字符串了
            if (count[c]!=0){//count是map容器，如果这个元素还有的用，那么就输出吧。
                cout<<c;
                count[c]--;
                sum--;
            }else{//如果这个元素已经没得用了，那就直接跳过。
                continue;
            }
        }
    }

while (a.size() < b.size()) a = "0" + a;
while (b.size() < a.size()) b = "0" + b;

int gcd(int a,int b){
    if (b==0) return a;
    else return gcd(b,a%b);
}

set<string> id;
    for (int i=0;i<m;i++){
        string s;
        cin>>s;
        id.insert(s);
    }
    vector<string> ans;
    for (auto it:id){
        if (people.find(it)==people.end()){
            ans.push_back(it);
        }else if(people.find(it)!=people.end()&&id.find(h1[it])==id.end()){
            ans.push_back(it);
        }
    }

string s;
s.find('a')==string::npos;//这个代表没有找到a这个元素

#include <bits/stdc++.h>
using namespace std;

int main(){
    string s="aaaaabcbdddd";//这个字符串只是举例
    int n=s.size();
    int slow=0;
    int fast=0;
    vector<string> res;
    while (slow<n){
        int c=s[slow];//读取slow指针指向的第一个字符
        while (fast<n){//随后fast指针开始移动，如果fast指针指向的字符和c相同，那就加1，不相同直接退出
            if (s[fast]!=c||fast==n-1){//这里要做一个防止越界的操作
                break;
            }else{
                fast++;
            }
        }
        string word=s.substr(slow,fast-slow);//这里需要解释一下第二个参数为什么不加1，因为fast指向的是第一个不同元素
        res.push_back(word);
        slow=fast;//将slow直接移动到fast的位置
    }
    for (int i=0;i<res.size();i++){
        cout<<res[i]<<" ";//这个地方我懒得改了，懂就行。
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main(){
    string s="5T2h4is i5s a3 te4st CA3a as10Z";//空格也算作一个字符
    int n=s.size();
    int pos=0;//单指针
    while (pos<n){
        char c=s[pos];
        if (isdigit(c)){
            string num;//待读取的数字，这个数字可能是两位数
            while (pos<n){
                if (!isdigit(s[pos])){
                    break;
                }else{
                    num+=s[pos];
                    pos++;
                }
            }
            int r=stoi(num);//stoi是一个把字符串数字转化为int的好函数。
            for (int i=0;i<r;i++){
                cout<<s[pos];
            }
            pos++;
        }else{
            cout<<s[pos];
            pos++;
        }
    }
    return 0;
}

string addition(string a,string b){
    while(a.size()<b.size()){
        a='0'+a;
    }
    while(b.size()<a.size()){
        b='0'+b;
    }//这里我前面提到过了，是为了方便后面的主程序做的预处理。
    int n=a.size();
    string ans1,ans;//ans1是初步结果，ans是返回结果，这个变量名起的有点变态。
    int t=0;//t是上一次剩下的溢出数
    for (int i=n-1;i>=0;i--){//最后一位才是个位
        int x=a[i]-'0';
        int y=b[i]-'0';//转化为int类型，注意不能用stoi
        char c=(x+y+t)%10+'0';
        t=(x+y+t)/10;//计算溢出的数字
        ans1=c+ans1;//加入答案
    }
    if (t!=0){
        ans1=char('0'+t)+ans1;//循环结束之后把溢出数加上去
    }
    bool flag=0;//去前导0逻辑
    for (int i=0;i<ans1.size();i++){
        if (flag){
            ans+=ans1[i];
        }else if(!flag&&ans1[i]!='0'){//遇到第一个非0数字，立刻结束去0
            ans+=ans1[i];
            flag=1;
        }
    }
    return ans;
}

bool isback_num(string a){
    string b;
    int n=a.size();
    for (int i=n-1;i>=0;i--){
        b+=a[i];
    }
    if (a==b){
        return true;
    }else{
        return false;
    }
}

bool isquare(int n){
    if (n<0) return false;
    int r=sqrt(n);
    return r*r==n;
}

string subtraction(string a,string b){
    string res,ans;
    bool flag=0;
    if (!cmp(a,b)){
        swap(a,b);
        flag=1;//控制正负
    }
    while (b.size()<a.size()){
        b='0'+b;
    }
    int n=a.size();
    int p=0;
    for (int i=n-1;i>=0;i--){
        int x=(a[i]-'0')-p;
        int y=(b[i]-'0');
        if (x>=y){
            int temp=(x-y);
            res+=(char)('0'+temp);
            p=0;
        }else{
            int temp=(10+x-y);
            res+=(char)('0'+temp);
            p=1;
        }
    }
    reverse(res.begin(),res.end());
    int pos=0;
    while (pos<res.size()&&res[pos]=='0'){
        pos++;
    }//新的去0逻辑。
    if (pos==res.size()) return "0";
    else{
        ans=res.substr(pos);
        if (flag) ans='-'+ans;
    }
    return ans;
}

string addition(string a,string b){
    while(a.size()<b.size()){
        a='0'+a;
    }
    while(b.size()<a.size()){
        b='0'+b;
    }//这里我前面提到过了，是为了方便后面的主程序做的预处理。
    int n=a.size();
    string ans1,ans;//ans1是初步结果，ans是返回结果，这个变量名起的有点变态。
    int t=0;//t是上一次剩下的溢出数
    for (int i=n-1;i>=0;i--){//最后一位才是个位
        int x=a[i]-'0';
        int y=b[i]-'0';//转化为int类型，注意不能用stoi
        char c=(x+y+t)%10+'0';
        t=(x+y+t)/10;//计算溢出的数字
        ans1=c+ans1;//加入答案
    }
    if (t!=0){
        ans1=char('0'+t)+ans1;//循环结束之后把溢出数加上去
    }
    bool flag=0;//去前导0逻辑
    for (int i=0;i<ans1.size();i++){
        if (flag){
            ans+=ans1[i];
        }else if(!flag&&ans1[i]!='0'){//遇到第一个非0数字，立刻结束去0
            ans+=ans1[i];
            flag=1;
        }
    }
    return ans;
}

string subtraction(string a,string b){
    string res,ans;
    bool flag=0;
    if (!cmp(a,b)){
        swap(a,b);
        flag=1;//控制正负
    }
    while (b.size()<a.size()){
        b='0'+b;
    }
    int n=a.size();
    int p=0;
    for (int i=n-1;i>=0;i--){
        int x=(a[i]-'0')-p;
        int y=(b[i]-'0');
        if (x>=y){
            int temp=(x-y);
            res+=(char)('0'+temp);
            p=0;
        }else{
            int temp=(10+x-y);
            res+=(char)('0'+temp);
            p=1;
        }
    }
    reverse(res.begin(),res.end());
    int pos=0;
    while (pos<res.size()&&res[pos]=='0'){
        pos++;
    }//新的去0逻辑。
    if (pos==res.size()) return "0";
    else{
        ans=res.substr(pos);
        if (flag) ans='-'+ans;
    }
    return ans;
}

int r=0,num=0;
    string s,ans;
    for (char c:a){
        num=r*10+(c-'0');
        s+=(num/b)+'0';
        r=num%b;//这个数字是上一轮得到的余数，应该定义在全局。
    }
    int pos=0;
    while (pos<s.size()-1&&s[pos]=='0'){
        pos++;
    }//去除前导0
    ans=s.substr(pos);

#include <bits/stdc++.h>
using namespace std;

string s;
int main(){
    unordered_map<string,int> n;
    n.emplace("yi",1),n.emplace("er",2),n.emplace("san",3),
    n.emplace("si",4),n.emplace("wu",5),n.emplace("liu",6),
    n.emplace("qi",7),n.emplace("ba",8),n.emplace("jiu",9),
    n.emplace("ling",0);
    vector<int> ans;
    for (int i=1;i<=11;i++){
        getline(cin,s);
        if (s.size()==1&&isdigit(s[0])){
            ans.push_back(stoi(s));
        }else if (s.size()>=4&&isalpha(s[0])){
            string t=s.substr(0,4);
            if (t=="sqrt"){
                int x=sqrt(stoi(s.substr(4)));
                ans.push_back(x);
            }else if(t=="ling"){
                ans.push_back(n[s]);
            }
        }else if(s.size()==2&&isalpha(s[0])){
            ans.push_back(n[s]);
        }else if(s.size()==3&&isalpha(s[0])){
            ans.push_back(n[s]);
        }else if(isdigit(s[0])){
            vector<int> nums;
            string m;
            string f;
            for (int i=0;i<s.size();i++){
                if (s[i]=='+'||s[i]=='-'||s[i]=='*'||s[i]=='/'||s[i]=='%'||s[i]=='^'){
                    f=s[i];
                    int y=stoi(m);
                    nums.push_back(y);
                    m.clear();
                }else{
                    m+=s[i];
                }
            }
            if (!m.empty()){
                int t=stoi(m);
                nums.push_back(t);
                m.clear();
            }
            if (f=="+"){
                ans.push_back(nums[0]+nums[1]);
            }
            if (f=="-"){
                ans.push_back(nums[0]-nums[1]);
            }
            if (f=="*"){
                ans.push_back(nums[0]*nums[1]);
            }
            if (f=="/"){
                ans.push_back(nums[0]/nums[1]);
            }
            if (f=="%"){
                if (nums[1]==0) ans.push_back(0); 
                else ans.push_back(nums[0] % nums[1]);
            }
            if (f=="^"){
                ans.push_back(pow(nums[0],nums[1]));
            }
        }
    }
    for (int i=0;i<ans.size();i++){
        cout<<ans[i];
    }
    return 0;
}

class Solution {
public:
    int search(vector<int>& a, int t) {
        int n=a.size();
        set<int> s;
        for (auto it:a){
            s.insert(it);
        }
        if (s.find(t)==s.end()){
            return -1;
        }else{
            int l=0,r=n-1;
            while (l<=r){
                int mid=(l+r)/2;
                if (a[mid]==t){
                    return mid;
                }else if(a[mid]>t){
                    r=mid-1;
                }else{
                    l=mid+1;
                }
            }
        }
        return -1;
    }
};

class Solution {
public:
    int searchInsert(vector<int>& a, int t) {
        int n=a.size();
        set<int> s;
        for (auto it:a){
            s.insert(it);
        }
        if (s.find(t)==s.end()){
            if (t<a[0]){
                return 0;
            }
            if (t>a[n-1]){
                return n;
            }
            for (int i=1;i<=n-1;i++){
                if (a[i]>t&&a[i-1]<t){
                    return i;
                }
            }
        }else{
            int l=0,r=n-1;
            while (l<=r){
                int mid=(l+r)/2;
                if (a[mid]==t){
                    return mid;
                }
                if (a[mid]>t){
                    r=mid-1;
                }
                if (a[mid]<t){
                    l=mid+1;
                }
            }
        }
        return 0;
    }
};

class Solution {
public:
    vector<int> searchRange(vector<int>& a, int t) {
        int n=a.size();
        set<int> s;
        for (auto it:a){
            s.insert(it);
        }
        if (s.empty()||s.find(t)==s.end()){
            return {-1,-1};
        }else{
            int ansl=0,ansr=0;
            int l=0,r=n-1;
            while (l<=r){
                int mid=(l+r)/2;
                if (a[mid]>t){
                    r=mid-1;
                }else{
                    l=mid+1;
                    ansr=l;
                }
            }
            l=0,r=n-1;
            while (l<=r){
                int mid=(l+r)/2;
                if (a[mid]>=t){
                    r=mid-1;
                    ansl=r;
                }else{
                    l=mid+1;
                }
            }
            return {ansl+1,ansr-1};
        }
        return {-1,-1};
    }
};

class Solution {
public:
    int mySqrt(int x) {
        int l=1,r=x;
        int ans=0;
        while (l<=r){
            int mid=l+(r-l)/2;
            if ((long long)mid*mid<=x){
                ans=mid;
                l=mid+1;
            }else{
                r=mid-1;
            }
        }
        return ans;
    }
};

class Solution {
public:
    bool isPerfectSquare(int x) {
        int l=1,r=x;
        int ans=0;
        while (l<=r){
            int mid=l+(r-l)/2;
            if ((long long)mid*mid<=x){
                ans=mid;
                l=mid+1;
            }else{
                r=mid-1;
            }
        }
        if ((long long)ans*ans==x){
            return 1;
        }else{
            return 0;
        }
    }
};

class Solution {
public:
    int removeElement(vector<int>& a, int v) {
        int n=a.size();
        int fastidx=0,slowidx=0;
        while (fastidx<n&&slowidx<n){
            if (a[fastidx]!=v){
                a[slowidx++]=a[fastidx];
            }
            fastidx++;
        }
        return slowidx;
    }
};

class Solution {
public:
    int removeDuplicates(vector<int>& a) {
        unordered_map<int,int> m;
        int n=a.size();
        for (int i=0;i<n;i++){
            m[a[i]]++;
        }
        int slowidx=0,fastidx=0;
        while (slowidx<n&&fastidx<n){
            if (m[a[fastidx]]==1){
                a[slowidx++]=a[fastidx];
            }else if(m[a[fastidx]]>1){
                m[a[fastidx]]--;
            }
            fastidx++;
        }
        return slowidx;
    }
};

class Solution {
public:
    void moveZeroes(vector<int>& a) {
        int n=a.size();
        int slowidx=0,fastidx=0;
        while (slowidx<n&&fastidx<n){
            if (a[fastidx]!=0){
                a[slowidx++]=a[fastidx];
            }
            fastidx++;
        }
        while (slowidx<n){
            a[slowidx++]=0;
        }
    }
};

class Solution {
public:
    bool backspaceCompare(string S, string T) {
        return build(S) == build(T);
    }

    string build(string str) {
        string ret;
        for (char ch : str) {
            if (ch != '#') {
                ret.push_back(ch);
            } else if (!ret.empty()) {
                ret.pop_back();
            }
        }
        return ret;
    }
};

var backspaceCompare = function(S, T) {
    let i = S.length - 1,
        j = T.length - 1,
        skipS = 0,
        skipT = 0;
    // 大循环
    while(i >= 0 || j >= 0){
        // S 循环
        while(i >= 0){
            if(S[i] === '#'){
                skipS++;
                i--;
            }else if(skipS > 0){
                skipS--;
                i--;
            }else break;
        }
        // T 循环
        while(j >= 0){
            if(T[j] === '#'){
                skipT++;
                j--;
            }else if(skipT > 0){
                skipT--;
                j--;
            }else break;
        }
        if(S[i] !== T[j]) return false;
        i--;
        j--;
    }
    return true;
};

class Solution {
public:
    vector<int> sortedSquares(vector<int>& a) {
        int n=a.size();
        for (int i=0;i<n;i++){
            a[i]=a[i]*a[i];
        }
        sort(a.begin(),a.end());
        return a;
    }
};

class Solution {
public:
    int minSubArrayLen(int t, vector<int>& a) {
        int n=a.size();
        int i=0,j=0;
        int minn=n;
        int sum=a[i];
        while (i<n&&j<n){
            if (sum<t){
                j++;
                if (j<n) sum+=a[j];
            }else{
                minn=min(minn,j-i+1);
                sum-=a[i];
                i++;
            }
        }
        if (sum<t&&i==0){
            return 0;
        }else{
            return minn;
        }
    }
};

class Solution {
public:
    int totalFruit(vector<int>& f) {
        unordered_map<int,int> cnt;
        int n=f.size();
        int ans=0;
        int left=0;
        for (int right=0; right<n; right++){
            cnt[f[right]]++;
            while (cnt.size()>2){
                cnt[f[left]]--;
                if (cnt[f[left]]==0) cnt.erase(f[left]);
                left++;
            }
            ans=max(ans, right-left+1);
        }
        return ans;
    }
};

class Solution {
public:
    string minWindow(string s, string t) {
        int n1 = s.size();
        int n2 = t.size();
        if (n1 < n2) return "";

        unordered_map<char,int> h1;
        for (auto c : t) h1[c]++;

        unordered_map<char,int> h2;
        int left = 0;
        int match = 0;
        int minlen = INT_MAX;
        int start = 0;

        for (int right = 0; right < n1; right++) {
            char c = s[right];
            if (h1.count(c)) {
                h2[c]++;
                if (h2[c] == h1[c]) match++;
            }

            while (match == (int)h1.size()) {
                if (right - left + 1 < minlen) {
                    minlen = right - left + 1;
                    start = left;
                }
                char d = s[left];
                if (h1.count(d)) {
                    h2[d]--;
                    if (h2[d] < h1[d]) match--;
                }
                left++;
            }
        }
        return minlen == INT_MAX ? "" : s.substr(start, minlen);
    }
};

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int top=0,bottom=n-1,left=0,right=n-1;
        int cur=1;
        vector<vector<int>> m(n,vector<int>(n));
        while (top<=bottom&&left<=right){
            for (int i=left;i<=right;i++){
                m[top][i]=cur;
                cur++;
            }
            top++;
            for (int i=top;i<=bottom;i++){
                m[i][right]=cur;
                cur++;
            }
            right--;
            if (top<=bottom){
                for (int i=right;i>=left;i--){
                    m[bottom][i]=cur;
                    cur++;
                }
                bottom--;
            }
            if (left<=right){
                for (int i=bottom;i>=top;i--){
                    m[i][left]=cur;
                    cur++;
                }
                left++;
            }
        }
        return m;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while (head!=NULL&&head->val==val){
            ListNode *temp=head;
            head=head->next;
            delete temp;
        }

        ListNode* cur=head;
        while (cur!=NULL&&cur->next!=NULL){
            if (cur->next->val==val){
                ListNode *temp=cur->next;
                cur->next=cur->next->next;
                delete temp;
            }else{
                cur=cur->next;
            }
        }
        return head;
    }
};

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则在头部插入节点
    void addAtIndex(int index, int val) {

        if(index > _size) return;
        if(index < 0) index = 0;        
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp=nullptr;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *temp;
        ListNode *cur=head;
        ListNode *pre=NULL;
        while (cur!=NULL){
            temp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=temp;
        }
        return pre;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *dummyhead=new ListNode(0);
        dummyhead->next=head;
        ListNode *cur=dummyhead;
        while (cur->next!=NULL&&cur->next->next!=NULL){
            ListNode *temp1=cur->next;
            ListNode *temp2=cur->next->next->next;
            cur->next=cur->next->next;
            cur->next->next=temp1;
            cur->next->next->next=temp2;
            cur=cur->next->next;
        }
        return dummyhead->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *dummy=new ListNode(0);
        dummy->next=head;
        ListNode *fast=dummy;
        ListNode *slow=dummy;
        while (n--&&fast!=NULL){
            fast=fast->next;
        }
        fast=fast->next;
        while (fast!=NULL){
            fast=fast->next;
            slow=slow->next;
        }
        slow->next=slow->next->next;
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *cur1=headA;
        ListNode *cur2=headB;
        int lenA=0,lenB=0;
        while (cur1!=NULL){
            lenA++;
            cur1=cur1->next;
        }
        while (cur2!=NULL){
            lenB++;
            cur2=cur2->next;
        }
        cur1=headA;
        cur2=headB;
        if (lenB>lenA){
            swap(lenA,lenB);
            swap(cur1,cur2);
        }
        int gap=lenA-lenB;
        while (gap--){
            cur1=cur1->next;
        }
        while (cur1!=NULL){
            if (cur1==cur2){
                return cur1;
            }
            cur1=cur1->next;
            cur2=cur2->next;
        }
        return NULL;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_map<ListNode*,int> v;
        while (head!=NULL){
            if (v.count(head)){
                return head;
            }
            v[head]++;
            head=head->next;
        }
        return NULL;
    }
};

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size()!=t.size()){
            return 0;
        }
        unordered_map<char,int> sh;
        unordered_map<char,int> th;
        for (auto c:s){
            sh[c]++;
        }
        for (auto c:t){
            th[c]++;
        }
        for (auto c:s){
            if (t.find(c)==string::npos){
                return 0;
            }else{
                if (th[c]!=sh[c]){
                    return 0;
                }
            }
        }
        return 1;
    }
};

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int> h;
        set<int> exist;
        vector<int> ans;
        for (auto it:nums1){
            h[it]++;
        }
        for (auto it:nums2){
            if (h.count(it)&&exist.find(it)==exist.end()){
                ans.push_back(it);
                exist.insert(it);
            }
        }
        return ans;
    }
};

int turnnum(int n){
    int res=0;
    while (n>0){
        int t=n%10;
        res+=t*t;
        n/=10;
    }
    return res;
}

class Solution {
public:
    bool isHappy(int n) {
        unordered_map<int,int> h;
        h.emplace(n,1);
        while (1){
            if (n==1){
                return 1;
            }
            n=turnnum(n);
            if (h.count(n)){
                return 0;
            }
            h[n]++;
        }
        return 0;
    }
};

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int t) {
        unordered_map<int,int> h;
        int n=nums.size();
        for (int i=0;i<n;i++){
            auto ans=h.find(t-nums[i]);
            if (ans!=h.end()){
                return {ans->second,i};
            }
            h[nums[i]]=i;
        }
        return {};
    }
};