备战2

–round()、floor()、ceil
2.1 2.6 -2.1 -2.6
floor : 不大于自变量的最大整数 2 2 -3 -3
ceil :不小于自变量的最大整数 3 3 -2 -2
round:四舍五入到最邻近的整数 2 3 -2 -3

–string

str.erase(s.begin()) //移除第一个字符
string s = to_string(xx); 
s.length(); 
string s1 = s;//直接拷贝
s1 = s1 + "ssdsd" //接入s1末尾
reverse(s1.begin(),s1.end()) //翻转字符串
'18' - 10 = '8'

–进制转换

vector<int> disit;

/*十进制num转换成radix进制
从disit.size()-1 --> 0 为radix进制数*/
int rem = 0;
do
{
    rem = num % radix;
    num = num / radix;
    disit.push_back(rem);
}while(num != 0);


//radix进制num转成十进制
string s = to_string(num);
int value = 0;
for(int i=0;i<s.length;i++)
{
    value = value*radix + (s[i]-'0');
}

–求num的位数

int n=0;
do
{
    num = num / 10;
    n++
}(while num != 0);

–sort、max

sort(begin,end,cmp); //#include <algorithm>
eg:数组使用：sort(s,s+n,cmp)
bool cmp(type a, type b)
{
    return a<b; //升序
}
int max(int a,int b);
int min(int a,int b)

–fill

fill(ite.begin(),ite.end,val); //#include <algorithm>
int a[500];
int b[500][500];
fill(a,a+500,val);
fill(b[0],b[0]+500*500,val);

–dijkstra（参考自柳婼女神）

fill(e[0],e[0]+n*n,INT_MAX);
fill(dis,dis+n,INT_MAX);
fill(visit,visit+n,false);
for(int i=0;i<n;i++) path[i]=i;
dis[src]=0;
while(true)
{
    int mindis=INT_MAX;
    int v=-1;
    for(int i=0;i<n;i++)
    {
        if(visit[i] == false && mindis > dis[i])
        {
            v = i;
            mindis = dis[i];
        }
    }
    if(v==-1)
        break;
    visit[v] = true;
    for(int i=0;i<n;i++)  //变种处~
    {
        if(visit[i] == false && e[v][i] != INT_MAX)
        {
            if(dis[i] > dis[v] + e[v][i])
            {
                dis[i] = dis[v] + e[v][i];
                path[i] = v;
            }
        }
    }
}


//输出src到des的路径：
void DFS(int src,int des)
{
    if(src == des)
    {
        cout << src << " ";
        return ;
    }
    DFS(src,path[des]);
    cout << des << " ";
}


//变种1：每条边存在另一权值cost，dis相等时，cost最小的路径
for(int i=0;i<n;i++)  //变种处~
{
    if(visit[i] == false && e[v][i] != INT_MAX)
    {
        if(dis[i] > dis[v] + e[v][i])
        {
            dis[i] = dis[v] + e[v][i];
            cost[i] = cost[v] + c[v][i]; 
            path[i] = v;
        }
        else if(dis[i] == dis[v] + e[v][i] && cost[i] > cost[v] + c[v][i])
        {
            cost[i] = cost[v] + c[v][i];
            path[i] = v;
        }
    }
}

//变种2：每个点有点权，dis相等时求点权和最小者
for(int i=0;i<n;i++)  //变种处~
{
    if(visit[i] == false && e[v][i] != INT_MAX)
    {
        if(dis[i] > dis[v] + e[v][i])
        {
            dis[i] = dis[v] + e[v][i];
            wei[i] = wei[v] + w[i];
            path[i] = v;
        }
        else if(dis[i] == dis[v] + e[v][i] && wei[i] < wei[v] + w[i])
        {
            wei[i] = wei[v] + w[i];
            path[i] = v;
        }
    }
}

//变种3：求最短路径的数目,num[src]=1，其他num[i]=0
for(int i=0;i<n;i++)  //变种处~
{
    if(visit[i] == false && e[v][i] != INT_MAX)
    {
        if(dis[i] > dis[v] + e[v][i])
        {
            dis[i] = dis[v] + e[v][i];
            num[i] = num[v];
            path[i] = v;
        }
        else if(dis[i] == dis[v] + e[v][i])
        {
            num[i] = num[i] + num [v];
        }
    }
}

还有一种解决变种的通用方法：先用最简单的dijkstra求得所有最短路径（因为有多条，所以path要用 vector path[n]），然后用DFS遍历每条最短路径，根据要求得到合适的最短路径。

for(int i=0;i<n;i++)  //变种处~
    {
        if(visit[i] == false && e[v][i] != INT_MAX)
        {
            if(dis[i] > dis[v] + e[v][i])
            {
                dis[i] = dis[v] + e[v][i];
                path[i].clear();
                path[i].push_back(v);
            }
            else if(dis[i] == dis[v] + e[v][i])
                path[i].push_back(v);
        }
    }
}

int optvalue
vector<int> tempp,p;//p即为所求路径
void DFS(int v) //v当前访问结点
{
    if(v == src)//从des点开始
    {
        tempp.push_back(v);
        int value = 路径tempp上的value值; //此处采用遍历tempp的方式求得这条最短路径的value
        if(value 优于 optvalue)
        {
            optvalue = value;
            p = tempp;
        }
        tempp.pop_back();
        return ;
    }
    tempp.push_back(v);
    for(int i = 0; i < path[v].size(); i++)
        dfs(path[v][i]);
    tempp.pop_back();
}

–求连通分量：

int cnt=0;
for(int i=1;i<=n;i++)
{
    if(visit[i] == false)
    {
        DFS(i);
        cnt++;
    }
}

–二分查找：

int BinSearch(int N[], int left, int right, int target)
{
    int mid;
    while(left<=right)
    {
        mid = (left+right) / 2;
        if(N[mid] == target)
            return mid;
        else if(N[mid] < target)
            left = mid+1;
        else
            right = mid-1;
    }
    return -1;
}

–DFS