最大的稳定版本号

某互联网公司2016年笔试的编程题。这里只是为了记录一下当时自己的解题思路，想来很多地方都有待改进。
第一题的大概内容是找到最大的稳定版本号，我当时为了赶时间直接做了一个排序，其实排序是不用的。
基本思路就是用一个结构体来储存主版本号，次版本号和修订次数，
只将稳定的版本（也就是次版本号为偶数的放进vector中）

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <sstream>
using namespace std;
#define LOCAL
struct distribution{
    int major;
    int minor;
    int patchLevel;
    distribution(int major,int minor,int level){
        this->major = major;
        this->minor = minor;
        this->patchLevel = level;   
    };
};

vector<distribution> distributions;


void storeDis(string str)
{
    int r= str.find_first_of(".");
    string ma = str.substr(0,r);
    string rs = str.substr(r+1);
    int r2 = rs.find_first_of(".");
    int major,minor,level=-1;   
    istringstream ss(ma); //major
    ss>>major;

    if(r2!=string::npos){
        string mi = rs.substr(0,r2);
        istringstream ss(mi);;
        ss>>minor; //minor
        string le = rs.substr(r2+1);
        istringstream ss2(le);
        ss2>>level;//level
    }
    else{
        istringstream ss(rs);
        ss>>minor;
    }

    //如果不稳定，直接跳过
    if(minor&1 !=0)
        return;
    distribution s(major,minor,level);
    distributions.push_back(s);


};

bool compareDis(distribution & a,distribution & b){
        if(a.major>b.major)
            return true;
        else if(a.major == b.major)
        {
            if(a.minor> b.minor)
                return true;
            else if(a.minor == b.minor)
            {
                if(a.patchLevel>b.patchLevel)
                    return true;
                else
                    return false;
            }
            else{
                return false;
            }
        }
        else{
            return false;
        }
}

void reCombine(distribution& dis){

    stringstream r;
    r<<dis.major<<"."<<dis.minor;
    if(dis.patchLevel!=-1)
        r<<"."<<dis.patchLevel;
    string result = r.str();
    cout<<result<<endl;

}


void getResult(){



    sort(distributions.begin(),distributions.end(),compareDis);
    distribution fir = distributions[0];
    reCombine(fir);

}
int main(){
#ifdef LOCAL
    freopen("in.txt","r",stdin);
#endif
    int n;  
    while(cin>>n){
        distributions.clear();
        while(n--){
            string dis;
            cin>>dis;
            storeDis(dis);
        }
        if(distributions.empty()){
            cout<<"no stable available"<<endl;
        }
        else if(distributions.size()==1){
            reCombine(distributions[0]);
        }
        else{
            getResult();
        }

    }


    return 0;


}

第二题好像更容易，我的想法是对各个数组分别排序，各用一个下标记录，如果都相同就放到结果数组中，如果不同，就对最小的数所在的数组的下标加1。
这样遍历到有一个数组的下标到结尾就可以了，因为结果是要求返回三个数组中都有的整数。

#include<iostream>
#include<vector>
#include<algorithm>
#define LOCAL
using namespace std;
vector<int>v1;
vector<int>v2;
vector<int>v3;
vector<int>result;


int main(){

#ifdef LOCAL
    freopen("in.txt","r",stdin);
#endif

    int n1,n2,n3;
    while(cin>>n1){
        v1.clear();
        v2.clear();
        v3.clear();
        result.clear();
        int num;
        while(n1--){            
            cin>>num;
            v1.push_back(num);
        };
        cin>>n2;
        while(n2--){
            cin>>num;
            v2.push_back(num);
        };
        cin>>n3;
        while(n3--){
            cin>>num;
            v3.push_back(num);
        };
        sort(v1.begin(),v1.end());
        sort(v2.begin(),v2.end());
        sort(v3.begin(),v3.end());


        int i = 0,j=0,k=0;
        while(i<v1.size()&&j<v2.size()&&k<v3.size()){
            if(v1[i]<v2[j]&&v1[i]<v3[k]){
                ++i;
                continue;
            }
            if(v2[j]<v1[i]&&v2[j]<v3[k]){
                ++j;
                continue;
            }
            if(v3[k]<v1[i]&&v3[k]<v2[j]){
                ++k;
                continue;
            }
            if(v1[i]==v2[j]&&v1[i]==v3[k]){
                result.push_back(v1[i]);
                ++i;++j;++k;
                continue;
            }
            if(v1[i]==v2[j]){
                if(v1[i]<v3[k])
                {
                    ++i;++j;continue;
                }else{
                    ++k;continue;
                }
            }
            if(v1[i]==v3[k]){
                if(v1[i]<v2[j])
                {
                    ++i;++k;continue;
                }else{
                    ++j;continue;
                }
            }
            if(v2[j]==v3[k]){
                if(v2[j]<v1[i])
                {
                    ++k;++j;continue;
                }else{
                    ++i;continue;
                }
            }
        }
        for(int i=0;i<result.size();i++){
            cout<<result[i]<<" ";
        }
        cout<<endl;
    }
    return 0;


}

第三题是计算死锁的线程组的数目，
感觉是用有向图可以求解。