22.01.09 总结

总的来说今天学到的东西不多

 

vector

又或者说动态数组更好？

头文件：#include<bits/stdc++.h>

头文件：#include<vector>

常用操作：

vector<int> num;//里面的int为容器数据类型
//感觉像是数组里的共用体
a.back();  
最后一个元素

a.front(); 
第一个（首个）元素

a.empty(); 
为空判断

a.pop_back();  
末尾出队

a.swap(b);   
交换a,b;

a.insert(a.begin()+1,5);  
在a[1]处插入一个5

a.size();
容器大小（数据数量），是一个数值

reverse(a.begin(),a.end());
将容器倒置

特性：

vector<int>num(100)分配100个int空间 像数组一样  也能通过下标访问

可以通过迭代器读取，不知道为什么要用迭代器，也可以通过下标访问

但是由于容器是动态的，不能这样写

vector <int>num;
num[0]=1;   (X)

因为此时num还没有空间  

如果这样就对了

vector <int> num（10）;
num[0]=1;

迭代器输出

    vector <int> num;

    vector <int>::iterator pos;
    for(int i=0;i<999;i++)
    {
        num.push_back(i);
    }
    for(pos=num.begin();pos!=num.end();pos++)
    {
        cout<<*pos<<" ";
        //printf("%c ",*pos);
    }

下标遍历输出

    vector <int> num;
    for(int i=0;i<999;i++)
    {
        num.push_back(i);
    }
    
    for(int i=0;i<999;i++)
    {
        cout<<num[i]<<" ";
    }

截取a中指定区间元素入b（和sort一样左闭右开）

vector<int>b(num.begin(),num.begin()+3);

测试代码

可以通过格式控制符改变     输出值的类型  入printf %c

#include<iostream>
#include<string>
#include<algorithm>
#include<functional>
#include<vector>
using namespace std;
int main()
{
    vector <int> num;
    for(int i=0;i<999;i++)
    {
        num.push_back(i);
    }

    for(int i=0;i<999;i++)
    {
        cout<<num[i]<<" ";
    }
    vector <int>::iterator pos;
    for(pos=num.begin();pos!=num.end();pos++)
    {
        cout<<*pos<<" ";
        //printf("%c ",*pos);
    }
    vector<int>b(num.begin(),num.begin()+3);
    for(pos=b.begin();pos!=b.end();pos++)
    {
        cout<<*pos<<" ";
        //printf("%c ",*pos);
    }
   // cout<<num>=b;貌似不行

}

今天又去复盘了一下树的基本操作，感觉树的推理还不是很熟练，但是基本上都是一个模板

中序和其他任意一个遍历建树  另一种遍历输出

也看到了树的复制，和深度计算，这些之前都忽略掉了，明天再学习一下

蓝桥上做了些练习题

其中有两道比较有意思

贴一下，发一下思路

样例输入

10

样例输出

3628800

一开始我惯性思维准备直接大数相乘了；

但是发现那样非常麻烦，然后采取了模拟手算乘法的方法

加一个进位器就好了

查了一下1000！的位数，只有2568位

字符串完全够了

解释放代码里面

#include<iostream>
#include<string>
#include<algorithm>
#include<functional>

#define LEN 10000
//10000*1000貌似也不是很大，不会超时
using namespace std;

int a[10000];

int main()
{
    int i,j,k;
    int n;
    int jinwei;
    a[0]=1;
    cin>>n;
    for(i=2; i<=n; i++) //从2开始阶乘 ,每次循环计算i阶乘的结果
    {
        jinwei=0;
        for(j=0; j<LEN; j++)//与记录位数的另一种方法不同，这里不用管jinwei是否为0，因为LEN远大于上限2568位
        {
            a[j]=a[j]*i+jinwei;//相应阶乘中的一项与当前所得临时结果的某位相乘加上进位
            jinwei=a[j]/10;
            a[j]%=10;
        }
    }
    for(i=LEN-1; ; i--)//去掉末尾的0不输出
    {
        if(a[i]!=0)
        break;
    }
    for(j=i; j>=0; j--)//倒序输出
        printf("%d",a[j]);
    return  0;

}

还有这道题

中心有点离谱，在我的印象中中心应该是重心，而在这里却是外心 ？？

这里补充一下概念就好了，没什么技术含量

重心：中线交点  （x1+x2+x3）/3 , (y1+y2+y3)/3

垂心：高线交点

内心：角平分线交点（内切圆）

外心：中垂线交点  （外切圆）

 一般来说这四心合一才是中心，即正三角形，挺奇怪的

代码

#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;

int main()
{
    double x1,x2,x3,y1,y2,y3;
    cin>>x1>>y1;
    cin>>x2>>y2;
    cin>>x3>>y3;

    double a,b,c;//三边
    a=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
    b=sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));
    c=sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));

    double C;
    C=a+b+c;//周长

    double cosxita;//θ
    double sinxita;
    cosxita=(a*a+b*b-c*c)/(2*a*b);

    sinxita=sqrt(1-pow(cosxita,2));
    double s=a*b*sinxita/2;//面积

    double A1,A2,B1,B2,C1,C2;
    A1=2*(x2-x1);
    B1=2*(y2-y1);
    C1=x2*x2-x1*x1+y2*y2-y1*y1;

    A2=2*(x3-x2);
    B2=2*(y3-y2);
    C2=x3*x3-x2*x2+y3*y3-y2*y2;
    double xw,yw;//外心  中心
    xw=(C1*B2-C2*B1)/(A1*B2-A2*B1);
    yw=(A1*C2-A2*C1)/(A1*B2-A2*B1);

    double x,y;//重心
    x=(x1+x2+x3)/3;
    y=(y1+y2+y3)/3;
    printf("%.2lf\n%.2lf\n%.2lf %.2lf\n%.2lf %.2lf\n",C,s,xw,yw,x,y);

}

补充一下，上面用到了面积公式  s=1.0/2*AB*sinc; 

这里是公式出处