auto min_values=min_element(v.begin(),v.end())
auto max_values=max_element(v.begin(),v.end())
会分别返回一个指向输入序列的最小元素以及最大元素的迭代器(里面存的是对应的物理地址)；
1.取 * 可以去除具体的最大以及最小值
2.不取 * 减去起始地址就能知道索引的位置

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n[]={1,4,5,7,22,3,8,5};
int len=sizeof(n)/sizeof(int);
//返回索引
cout<<max_element(n,n+len)-n<<endl;
//返回值
cout<<*max_element(n,n+len)<<endl;
return 0;
}

Problem Description

The Head Elder of the tropical island of Lagrishan has a problem. A burst of foreign aid money was spent on extra roads between villages some years ago. But the jungle overtakes roads relentlessly, so the large road network is too expensive to maintain. The Council of Elders must choose to stop maintaining some roads. The map above on the left shows all the roads in use now and the cost in aacms per month to maintain them. Of course there needs to be some way to get between all the villages on maintained roads, even if the route is not as short as before. The Chief Elder would like to tell the Council of Elders what would be the smallest amount they could spend in aacms per month to maintain roads that would connect all the villages. The villages are labeled A through I in the maps above. The map on the right shows the roads that could be maintained most cheaply, for 216 aacms per month. Your task is to write a program that will solve such problems.
Input
The input consists of one to 100 data sets, followed by a final line containing only 0. Each data set starts with a line containing only a number n, which is the number of villages, 1 < n < 27, and the villages are labeled with the first n letters of the alphabet, capitalized. Each data set is completed with n-1 lines that start with village labels in alphabetical order. There is no line for the last village. Each line for a village starts with the village label followed by a number, k, of roads from this village to villages with labels later in the alphabet. If k is greater than 0, the line continues with data for each of the k roads. The data for each road is the village label for the other end of the road followed by the monthly maintenance cost in aacms for the road. Maintenance costs will be positive integers less than 100. All data fields in the row are separated by single blanks. The road network will always allow travel between all the villages. The network will never have more than 75 roads. No village will have more than 15 roads going to other villages (before or after in the alphabet). In the sample input below, the first data set goes with the map above.
Output
The output is one integer per line for each data set: the minimum cost in aacms per month to maintain a road system that connect all the villages. Caution: A brute force solution that examines every possible set of roads will not finish within the one minute time limit.

Sample Input

9
A 2 B 12 I 25
B 3 C 10 H 40 I 8
C 2 D 18 G 55
D 1 E 44
E 2 F 60 G 38
F 0
G 1 H 35
H 1 I 35
3 A 2 B 10 C 40
B 1 C 20
0

Sample Output

216
30

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;

const int MAXN=100;

struct Edge{
    int from;
    int to;
    int length;
    bool operator<(const Edge& e) const{//жиди<a
        return length<e.length;
    }
};

Edge edge[MAXN*MAXN];
int father[MAXN];
int height[MAXN];

void Initial(int n){
    for(int i=0;i<n;i++){
        father[i]=i;
        height[i]=0;
    }
}

int Find(int x){
    if(father[x]!=x) return Find(father[x]);
    else return father[x];
}

void Union(int x,int y){
    x=Find(x);
    y=Find(y);
    if(x!=y){
        if(height[x]<height[y]) father[x]=y;
        else if(height[x]>height[y]) father[y]=x;
        else{
            father[y]=x; height[x]++;
        }
    }
}

int Kruskal(int n,int edgeNumber){
    Initial(n);
    sort(edge,edge+edgeNumber);
    int sum=0;
    for(int i=0;i<edgeNumber;i++){
        Edge current=edge[i];
        //cout<<current.from<<"->"<<current.to<<" "<<current.length<<endl;
        if(Find(current.from)!=Find(current.to)){
            Union(current.from,current.to);
            sum+=current.length;
        }
    }
    return sum;
}

int main(){
    int n;
    while(cin>>n){
        if(n==0) break;
        int k=0;
        for(int i=0;i<n-1;i++){
            char v; int num;
            cin>>v>>num;
            for(int j=0;j<num;j++){
                char v1; int length;
                cin>>v1>>length;
                edge[k].from=i;
                edge[k].to=v1-'A';
                edge[k].length=length;
                k++;
            }
        }
        int answer=Kruskal(n,k);
        cout<<answer<<endl;
    }
}

Problem Description
Ali has taken the Computer Organization and Architecture course this term. He learned that there may be dependence between instructions, like WAR (write after read), WAW, RAW.
If the distance between two instructions is less than the Safe Distance, it will result in hazard, which may cause wrong result. So we need to design special circuit to eliminate hazard. However the most simple way to solve this problem is to add bubbles (useless operation), which means wasting time to ensure that the distance between two instructions is not smaller than the Safe Distance.
The definition of the distance between two instructions is the difference between their beginning times.
Now we have many instructions, and we know the dependent relations and Safe Distances between instructions. We also have a very strong CPU with infinite number of cores, so you can run as many instructions as you want simultaneity, and the CPU is so fast that it just cost 1ns to finish any instruction.
Your job is to rearrange the instructions so that the CPU can finish all the instructions using minimum time.
Input
The input consists several testcases.
The first line has two integers N, M (N <= 1000, M <= 10000), means that there are N instructions and M dependent relations.
The following M lines, each contains three integers X, Y , Z, means the Safe Distance between X and Y is Z, and Y should run after X. The instructions are numbered from 0 to N - 1.
Output
Print one integer, the minimum time the CPU needs to run.

Sample Input

5 2
1 2 1
3 4 1

Sample Output

2

Hint
In the 1st ns, instruction 0, 1 and 3 are executed;
In the 2nd ns, instruction 2 and 4 are executed.
So the answer should be 2.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<climits>

using namespace std;

const int MAXN=1001;
const int INF=INT_MAX;

struct Edge{
    int to;
    int length;
    Edge(int t,int l):to(t),length(l){}
};

vector<Edge> graph[MAXN];//邻接表
int earliest[MAXN];//最早开始时间
int latest[MAXN];//最晚开始时间
int inDegree[MAXN];

void CriticalPath(int n){
    vector<int> topology;//拓扑序列
    queue<int> node;
    for(int i=0;i<n;i++){
        if(inDegree[i]==0){
            node.push(i);
            earliest[i]=1;//初始化为1,题目中的要求：1ns
        }
    }
    while(!node.empty()){
        int u=node.front();
        topology.push_back(u);
        node.pop();
        for(int i=0;i<graph[u].size();i++){
            int v=graph[u][i].to;
            int l=graph[u][i].length;
            earliest[v]=max(earliest[v],earliest[u]+l);//正向找最大，形成earliest
            inDegree[v]--;
            if(inDegree[v]==0) node.push(v);
        }
    }
    for(int i=topology.size()-1;i>=0;i--){
        int u=topology[i];
        if(graph[u].size()==0) latest[u]=earliest[u];//汇点的最晚开始时间初始化
        else latest[u]=INF;//非汇点的最晚开始时间的初始化
        for(int j=0;j<graph[u].size();j++){
            int v=graph[u][j].to;
            int l=graph[u][j].length;
            latest[u]=min(latest[u],latest[v]-l);//逆向找最小，形成latest
        }
    }
}

int main(){
    int n,m;
    while(cin>>n>>m){
        memset(graph,0,sizeof(graph));
        memset(earliest,0,sizeof(earliest));
        memset(latest,0,sizeof(latest));
        memset(inDegree,0,sizeof(inDegree));
        while(m--){
            int from,to,length;
            cin>>from>>to>>length;
            graph[from].push_back(Edge(to,length));
            inDegree[to]++;
        }
        CriticalPath(n);
        int answer=0;
        for(int i=0;i<n;i++){
            answer=max(answer,earliest[i]);
        }
        cout<<answer<<endl;
    }
}

Description
A subsequence of a given sequence is the given sequence with some elements (possible none) left out. Given a sequence X = < x1, x2, …, xm > another sequence Z = < z1, z2, …, zk > is a subsequence of X if there exists a strictly increasing sequence < i1, i2, …, ik > of indices of X such that for all j = 1,2,…,k, xij = zj. For example, Z = < a, b, f, c > is a subsequence of X = < a, b, c, f, b, c > with index sequence < 1, 2, 4, 6 >. Given two sequences X and Y the problem is to find the length of the maximum-length common subsequence of X and Y.

Input
The program input is from the std input. Each data set in the input contains two strings representing the given sequences. The sequences are separated by any number of white spaces. The input data are correct.

Output
For each set of data the program prints on the standard output the length of the maximum-length common subsequence from the beginning of a separate line.

Sample Input

abcfbc abfcab
programming contest
abcd mnp

Sample Output

4
2
0

#include<iostream>
#include<cstdio>
#include<cstring>
//最长公共子序列
using namespace std;

const int MAXN=1001;
char s1[MAXN];
char s2[MAXN];
int dp[MAXN][MAXN];

int main(){
    while(scanf("%s%s",s1+1,s2+1)!=EOF){//从下标1开始输入
        int n=strlen(s1+1);
        int m=strlen(s2+1);
        for(int i=0;i<=n;i++){
            for(int j=0;j<=m;j++){
                if(i==0||j==0){//边界条件初始化
                    dp[i][j]=0;
                    continue;
                }
                //状态转移方程
                if(s1[i]==s2[j]) dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
        cout<<dp[n][m]<<endl;
    }
}

一、用strtok函数进行字符串分割

原型： char *strtok(char *str, const char *delim);

功能：分解字符串为一组字符串。

参数说明：str为要分解的字符串，delim为分隔符字符串。

返回值：从str开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。

其它：strtok函数线程不安全，可以使用strtok_r替代。

示例：

//借助strtok实现split
#include <string.h>
#include <stdio.h>

int main()
{
    char s[] = "Golden Global   View,disk * desk";
    const char *d = " ,*";
    char *p;
    p = strtok(s,d);
    while(p)
    {
        printf("%s\n",p);
        p=strtok(NULL,d);
    }

    return 0;
}

运行效果如下图所示：

二、用STL进行字符串的分割

涉及到string类的两个函数find和substr：
1、find函数
原型：size_t find ( const string& str, size_t pos = 0 ) const;
功能：查找子字符串第一次出现的位置。
参数说明：str为子字符串，pos为初始查找位置。
返回值：找到的话返回第一次出现的位置，否则返回string::npos

2、substr函数
原型：string substr ( size_t pos = 0, size_t n = npos ) const;
功能：获得子字符串。
参数说明：pos为起始位置（默认为0），n为结束位置（默认为npos）
返回值：子字符串

实现如下：

//字符串分割函数
std::vector<std::string> split(std::string str,std::string pattern)
{
  std::string::size_type pos;
  std::vector<std::string> result;
  str+=pattern;//扩展字符串以方便操作
  int size=str.size();

  for(int i=0; i<size; i++)
  {
    pos=str.find(pattern,i);
    if(pos<size)
    {
      std::string s=str.substr(i,pos-i);
      result.push_back(s);
      i=pos+pattern.size()-1;
    }
  }
  return result;
}

完整代码：

/*
    File   : split1.cpp
    Author  : Mike
    E-Mail  : Mike_Zhang@live.com
 */
#include <iostream>
#include <string>
#include <vector>

//字符串分割函数
std::vector<std::string> split(std::string str,std::string pattern)
{
  std::string::size_type pos;
  std::vector<std::string> result;
  str+=pattern;//扩展字符串以方便操作
  int size=str.size();

  for(int i=0; i<size; i++)
  {
    pos=str.find(pattern,i);
    if(pos<size)
    {
      std::string s=str.substr(i,pos-i);
      result.push_back(s);
      i=pos+pattern.size()-1;
    }
  }
  return result;
}

int main()
{
  std::string str;
  std::cout<<"Please input str:"<<std::endl;
  //std::cin>>str;
  getline(std::cin,str);
  std::string pattern;
  std::cout<<"Please input pattern:"<<std::endl;
  //std::cin>>pattern;
  getline(std::cin,pattern);//用于获取含空格的字符串
  std::vector<std::string> result=split(str,pattern);
  std::cout<<"The result:"<<std::endl;
  for(int i=0; i<result.size(); i++)
  {
    std::cout<<result[i]<<std::endl;
  }

  std::cin.get();
  std::cin.get();
  return 0;
}
运行效果如下图所示：

三、用Boost进行字符串的分割

用boost库的正则表达式实现字符串分割
实现如下：

std::vector<std::string> split(std::string str,std::string s)
{
    boost::regex reg(s.c_str());
    std::vector<std::string> vec;
    boost::sregex_token_iterator it(str.begin(),str.end(),reg,-1);
    boost::sregex_token_iterator end;
    while(it!=end)
    {
        vec.push_back(*it++);
    }
    return vec;

}
完整代码：

//本程序实现的是利用正则表达式对字符串实现分割
//运行环境   VC6.0 + boost 库
/*
    File   : split2.cpp
    Author  : Mike
    E-Mail  : Mike_Zhang@live.com
*/
#include <iostream>
#include <cassert>
#include <vector>
#include <string>
#include "boost/regex.hpp"

std::vector<std::string> split(std::string str,std::string s)
{
    boost::regex reg(s.c_str());
    std::vector<std::string> vec;
    boost::sregex_token_iterator it(str.begin(),str.end(),reg,-1);
    boost::sregex_token_iterator end;
    while(it!=end)
    {
        vec.push_back(*it++);
    }
    return vec;
}
int main()
{
    std::string str,s;
    str="sss/ddd/ggg/hh";
    s="/";
    std::vector<std::string> vec=split(str,s);
    for(int i=0,size=vec.size();i<size;i++)
    {
        std::cout<<vec[i]<<std::endl;
    }
    std::cin.get();
    std::cin.get();
    return 0;
}

运行效果如下图所示：

补充：

最近发现boost里面有自带的split的函数，如果用boost的话，还是直接用split的好，这里就不多说了，代码如下：

#include <iostream>
#include <string>
#include <vector>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>

using namespace std;

int main()
{
 string s = "sss/ddd,ggg";
 vector<string> vStr;
 boost::split( vStr, s, boost::is_any_of( ",/" ), boost::token_compress_on );
 for( vector<string>::iterator it = vStr.begin(); it != vStr.end(); ++ it )
  cout << *it << endl;
 return 0;
}
#include <iostream>
#include <string>
#include <vector>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>

using namespace std;

int main()
{
 string s = "sss/ddd,ggg";
 vector<string> vStr;
 boost::split( vStr, s, boost::is_any_of( ",/" ), boost::token_compress_on );
 for( vector<string>::iterator it = vStr.begin(); it != vStr.end(); ++ it )
  cout << *it << endl;
 return 0;
}

希望本文所述对大家的C++程序设计有所帮助。

代码

void main()
{
    vector<int> t;
    t.push_back(1);
    t.push_back(2);
    t.push_back(3);
    t.push_back(4);
    t.push_back(6);
    t.push_back(7);
    t.push_back(8);


    int low=lower_bound(t.begin(),t.end(),5)-t.begin();
    int upp=upper_bound(t.begin(),t.end(),5)-t.begin();
    cout<<low<<endl;
    cout<<upp<<endl;


    system("pause");
}

因为用labelimg给图片打标签的时候打错了，本来是water dispenser弄成了drinking_fountain了，尴尬_(:з)∠)_，并且已经标了1500张了，只能自己写程序改，xml文件示例如下：

<?xml version='1.0' encoding='us-ascii'?>
<annotation verified="no">
  <folder>drinking_fountain</folder>
  <filename>1</filename>
  <path>E:\LabelImgv1.3.3\windows_v1.3.3\drinking_fountain\1.jpg</path>
  <source>
    <database>Unknown</database>
  </source>
  <size>
    <width>720</width>
    <height>1280</height>
    <depth>3</depth>
  </size>
  <segmented>0</segmented>
  <object>
    <name>drinking_fountain</name>
    <pose>Unspecified</pose>
    <truncated>0</truncated>
    <difficult>0</difficult>
    <bndbox>
      <xmin>153</xmin>
      <ymin>6</ymin>
      <xmax>587</xmax>
      <ymax>1157</ymax>
    </bndbox>
  </object>
</annotation>

用来修改的python代码的如下：

import os
import os.path
from xml.etree.ElementTree import parse, Element
#批量修改xml中内容
def test():
    path = "E:\LabelImgv1.3.3\windows_v1.3.3\drinking_fountain_label/"#xml文件所在的目录
    files = os.listdir(path)  # 得到文件夹下所有文件名称
    s = []
    for xmlFile in files:  # 遍历文件夹
        if not os.path.isdir(xmlFile):  # 判断是否是文件夹,不是文件夹才打开
            print
            xmlFile
            pass
        path = "E:\LabelImgv1.3.3\windows_v1.3.3\drinking_fountain_label/"
        print(xmlFile)
        path1 = "E:\LabelImgv1.3.3\windows_v1.3.3\drinking_fountain_label/"+xmlFile#定位当前处理的文件的路径
        newStr = os.path.join(path, xmlFile)
        name = "water dispenser"
        dom = parse(newStr)  ###最核心的部分,路径拼接,输入的是具体路径
        root = dom.getroot()
        print(root)
        for obj in root.iter('object'):#获取object节点中的name子节点
            obj.find('name').text=name
            name1 = obj.find('name').text#修改
            print(name1)
        dom.write(path1, xml_declaration=True)#保存到指定文件
        pass
if __name__ == '__main__':
    test()

题目：

n 个小孩围坐成一圈，并按顺时针编号为1,2,…,n，从编号为 p 的小孩顺时针依次报数，由1报到m ，当报到 m 时，该小孩从圈中出去，然后下一个再从1报数，当报到 m 时再出去。如此反复，直至所有的小孩都从圈中出去。请按出去的先后顺序输出小孩的编号。

Input:

每行是用空格分开的三个整数，第一个是n,第二个是p,第三个是m (0 < m,n < 300)。最后一行是: 0 0 0

Output:

按出圈的顺序输出编号，编号之间以逗号间隔。

Sample Input:

8 3 4
0 0 0

Sample Output:

6,2,7,4,3,5,1,8

#include<iostream>
#include<cstdio>
#include<queue>

using namespace std;
//用循环队列的方式解决约瑟夫问题
int main(){
    int n,p,m;
    while(cin>>n>>p>>m){
        queue<int> children;
        for(int i=1;i<=n;i++){
            children.push(i);
        }
        //使编号为p的小孩放在队首
        for(int i=1;i<p;i++){
            //这两句实现了循环队列，将要pop出去的再次放入队尾
            children.push(children.front());
            children.pop();
        }
        //m-1个小孩重新入队
        while(!children.empty()){
            for(int i=1;i<m;i++){
                children.push(children.front());
                children.pop();
            }
            //将第m个小孩出队
            if(children.size()==1) cout<<children.front()<<endl;
            else cout<<children.front();
            children.pop();
        }
    }
}

一段很简单的爬虫程序，爬取的网站为http://www.tianqihoubao.com，可以自己修改爬取城市以及爬取的月份，这里爬取的是1到7月的数据

from bs4 import BeautifulSoup
import requests
import pymysql
import warnings
# import pinyin
# from pinyin import PinYin
from pypinyin import pinyin, lazy_pinyin
import pypinyin
warnings.filterwarnings("ignore")

conn = pymysql.connect(host='localhost', user='root', passwd='root', db='test2', port=3306, charset='utf8')
cursor = conn.cursor()
def get_temperature(url,city):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,  like Gecko) Chrome/63.0.3239.132 Safari/537.36'}           # 设置头文件信息
    response = requests.get(url,  headers=headers).content    # 提交requests get 请求
    soup = BeautifulSoup(response,  "lxml")       # 用Beautifulsoup 进行解析

    conmid2 = soup.findAll('div',  class_='wdetail')
    # conmid2 = conmid.findAll('div',  class_='wdetail')

    for info in conmid2:
        tr_list = info.find_all('tr')[1:]       # 使用切片取到第三个tr标签
        for index,  tr in enumerate(tr_list):     # enumerate可以返回元素的位置及内容
            td_list = tr.find_all('td')
            # if index == 0:

            date = td_list[0].text.strip().replace("\n", "")  # 取每个标签的text信息，并使用replace()函数将换行符删除
            weather = td_list[1].text.strip().replace("\n", "").split("/")[0].strip()
            temperature = td_list[2].text.strip().replace("\n",  "").split("/")[0].strip()
            wind = td_list[3].text.strip().replace("\n",  "").split("/")[0].strip()

            # else:
            #     city_name = td_list[0].text.replace('\n',  '')
            #     weather = td_list[4].text.replace('\n',  '')
            #     wind = td_list[5].text.replace('\n',  '')
            #     max = td_list[3].text.replace('\n',  '')
            #     min = td_list[6].text.replace('\n',  '')

            print(city,date,  weather,  wind,  temperature)
            cursor.execute('insert into weather(city, date, weather, wind, temp) values(%s, %s, %s, %s, %s)'
                           ,  (city,  date,  weather,  wind,  temperature ))
if __name__=='__main__':

    # citys1= ["成都市","广元市","绵阳市","德阳市","南充市","广安市","遂宁市","内江市","乐山市","自贡市","泸州市","宜宾市","攀枝花市","巴中市","达州市","资阳市","眉山市","雅安市","崇州市","邛崃市","都江堰市","彭州市","江油市","什邡市","广汉市","绵竹市","阆中市","华蓥市","峨眉山市","万源市","简阳市","西昌市","康定市","马尔康市","隆昌市"]
    # citys1= ["郑州市","开封市","洛阳市","平顶山市","安阳市","鹤壁市","新乡市","焦作市","濮阳市","许昌市","漯河市","三门峡市","南阳市","商丘市","周口市","驻马店市","信阳市","荥阳市","新郑市","登封市","新密市","偃师市","孟州市","沁阳市","卫辉市","辉县市","林州市","禹州市","长葛市","舞钢市","义马市","灵宝市","项城市","巩义市","邓州市","永城市","汝州市","济源市"]
    # citys1= ["呼和浩特市","包头市","乌海市","赤峰市","通辽市","鄂尔多斯市","呼伦贝尔市","巴彦淖尔市","乌兰察布市","霍林郭勒市","满洲里市","牙克石市","扎兰屯市","额尔古纳市","根河市","丰镇市","乌兰浩特市","阿尔山市","二连浩特市","锡林浩特市"]
    # citys1= ["沈阳市","大连市","鞍山市","抚顺市","本溪市","丹东市","锦州市","营口市","阜新市","辽阳市","盘锦市","铁岭市","朝阳市","葫芦岛市","新民市","瓦房店市","庄河市","海城市","东港市","凤城市","凌海市","北镇市","盖州市","大石桥市","灯塔市","调兵山市","开原市","北票市","凌源市","兴城市"]
    # citys1= ["葫芦岛市","新民市","瓦房店市","庄河市","海城市","东港市","凤城市","凌海市","北镇市","盖州市","大石桥市","灯塔市","调兵山市","开原市","北票市","凌源市","兴城市"]
    citys1= ["开原市","北票市","凌源市","兴城市"]


    for city in citys1:
        city1 = ''.join(lazy_pinyin(city[:-1]))
        print(city1)
        urls = ['http://www.tianqihoubao.com/lishi/'+city1+'/month/201801.html',
                'http://www.tianqihoubao.com/lishi/'+city1+'/month/201802.html',
                'http://www.tianqihoubao.com/lishi/'+city1+'/month/201803.html',
                'http://www.tianqihoubao.com/lishi/'+city1+'/month/201804.html',
                'http://www.tianqihoubao.com/lishi/'+city1+'/month/201805.html',
                'http://www.tianqihoubao.com/lishi/'+city1+'/month/201806.html',
                'http://www.tianqihoubao.com/lishi/'+city1+'/month/201807.html']
        for url in urls:
            get_temperature(url, city)
        conn.commit()