由于最近玩机器人，所以总涉及到一些导航地图数据的处理，需要发任务，添加导航点，发送自由导航信息，少不了与canvas打交道了。

首先我们好弄清楚是什么正弦余弦定理，什么是勾股定理，角度和弧度的换算，其实我也差不多忘光光了~~

忘掉不丢人，百度走起~~，哈哈哈。。。。

下图就是点击拖动出来的东西，圆表示机器人，线表示机器的方向，目前我们已知的就是两个点的坐标，一个是圆心的坐标和鼠标移动过程的坐标，通过这连个左边我们要计算出圆的半径（这里的圆半径不是指机器人那个圆的半径，是鼠标时和拖动后产生的圆的半径）



我们先看第一个公式，求圆上任意一点的点坐标





计算两点间的距离我们就的用勾股定理了，这个距离也就是我们的圆的半径

  (a,b 为直角边，c为斜边)

好了，根据上面两条公式可以实现我们想需要的了

我们来就求个弧度，这里会用到反余弦函数哦~~

const countRadius(start:any, end: any) => {
  const [sx, sy, ex, ey] = [
    start.offsetX ? start.offsetX : start.x,
    start.offsetY ? start.offsetY : start.y,
    end.offsetX ? end.offsetX : end.x,
    end.offsetY ? end.offsetY : end.y,
  ];
  return Math.sqrt(Math.pow(ex - sx, 2) + Math.pow(ey - sy, 2));
}

const radius = countRadius(startPoint, lastPoint);

let radian = Math.acos((lastPoint.offsetX - startPoint.offsetX) / radius);

发现感觉挺完美的，我们逆时针绕一圈，弧度数出来了，但是发现上半圆和下半圆的结果好像是对称的关系，上半圆是0~π，下半圆是从π-0，我们判断下如果是下半圆我就用2π-radian就好了。

if (lastPoint.offsetY - startPoint.offsetY > 0) radian = 2*Math.PI - radian;

 

紧接上一篇：http://blog.csdn.net/yinhun2012/article/details/79384273
这一篇我们来推导一些常用的三角函数公式，主要方便以后图形程序中的计算。
1.余弦定理公式
余弦定义主要作用是依靠已知三角形的两条边及其夹角，求第三边的情况，如下图：

这里我们不处理向量（矢量）运算，单纯的从标量数值长度的推算入手，建立垂线后，得到的直角三角形ADC，可以通过勾股定理（前面推过）和sin²α+cos²α=1得到上面两个公式，后面的公式对我们求角度有很大帮助，而且这两个公式对后面图形方面计算会起到很大的帮助。

1.正弦定理的推导，前面有余弦定理，那么肯定就有一个对应的正弦定理了。
ps：这里要了解一个外接圆的概念，就是三角形△ABC的三个顶点都在一个圆上，那么这个圆就是△ABC的外接圆，其实这个也好反向理解，比如我们先画一个圆，然后任意在圆上取三点，连接三点就是一个三角形，但是假如我们不知道三角形的外接圆，要怎么去绘画和证明呢，如下图：

上面我们通过两条垂直平分线，就能得到△AOB和△BOC，且两三角形为等腰三角形（这个很好看出来，△AOB被平分成共边的两个一样的直角三角形），那么OA = OB = OC，所以O为圆心做半径OA的圆就是外接圆了。
接下来继续推导正弦公式，如下图：

上面我们推导了外接圆，那么接下来我们只需要建立等腰三角形△AoB △AoC △ BoC，将∠A转化成∠θ，就能得到上面的正弦定理了。
接下来到实际程序应用环节了，其实在实际项目开发中，余弦定理我用的还是挺多的，比如：


using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AngleFunc : MonoBehaviour {

    public GameObject PointA;
    public GameObject PointB;
    public GameObject PointC;

    void Start()
    {
        {  //构建一个三角形
            GameObject[] gos = new GameObject[3];
            gos[0] = PointA;
            gos[1] = PointB;
            gos[2] = PointC;
            for (int i = 0; i < gos.Length; i++)
            {
                LineRenderer line = gos[i].AddComponent<LineRenderer>();
                line.positionCount = 2;
                line.startWidth = 0.1f;
                line.endWidth = 0.1f;
                int index = i + 1;
                if (index >= gos.Length)
                    index = 0;
                line.SetPosition(0, gos[i].transform.position);
                line.SetPosition(1, gos[index].transform.position);
            }
        }
        //用余弦定理计算角度
        Vector3 AB = PointB.transform.position - PointA.transform.position;
        Vector3 BC = PointC.transform.position - PointB.transform.position;
        Vector3 AC = PointC.transform.position - PointA.transform.position;
        //计算∠A的夹角
        float angle1 = Mathf.Acos((getVectorLengthPow2(AB) + getVectorLengthPow2(AC) - getVectorLengthPow2(BC)) / (2 * Mathf.Sqrt(getVectorLengthPow2(AB) * getVectorLengthPow2(AC)))) * Mathf.Rad2Deg;
        //用自带的api计算角度
        float angle2 = Vector3.Angle(AB, AC);
#if UNITY_EDITOR
        Debug.LogFormat("angle1 = {0} angle2 = {1}", angle1, angle2);
#endif
    }
	
    private float getVectorLengthPow2(Vector3 vec)
    {
        return Mathf.Pow(vec.x, 2) + Mathf.Pow(vec.y, 2) + Mathf.Pow(vec.z, 2);
    }
	
}
代码比较少，直接贴上来了，主要就是用三角函数计算夹角值，其实unity中有自带的api，但是我们要知道公式的推导来源

勾股定理：c²=a²+b²
锐角：大于0而小于90的角
正弦：在直角三角形中，任意一锐角∠A的对边(a)与斜边(c)的比叫做∠A的正弦，记作sinA，如上图，即sinA=a/c
余弦：∠A的余弦是它的邻边(b)比三角形的斜边(c)，即cosA=b/c，也可写为cosA=AC/AB。
正切：∠A的正切是它的对边(a)邻边(b)，即tanA=a/b，也可写为tanA=BC/AC。

一个角的正弦平方加这个角的余弦平方等于1，即 (sinA)²+(cosA)²=1
tanA=sinA/cosA。分母(cosA)不能等于0

[HihoCoder-1696]
计算折线的中点。(题号hihocoder)
思路：先计算折线的总长度，然后算出一半的长度，然后后面对每段折线进行求和，只要和值小于一半就继续求和，知道大于等于如果大于则通过多出来的部分，然后根据勾股定理（余弦定理，正弦定理）算出中点的x值，y值。
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int maxn=1e6+50;
int n;
double seg[maxn],length,mid,ans_x,ans_y,Sin[maxn],Cos[maxn];

struct Node{
	int x,y;
}node[maxn];

int main(){
	while(scanf("%d",&n)!=EOF){
		memset(node,0,sizeof(node));
		memset(seg,0,sizeof(seg));
		memset(Cos,0,sizeof(Cos));
		memset(Sin,0,sizeof(Sin));
		length=0;
		for(int i=0;i<n;i++){
			scanf("%d%d",&node[i].x,&node[i].y);
			if(i>0){
				int dx=node[i].x-node[i-1].x;
				int dy=node[i].y-node[i-1].y;
				seg[i]=sqrt(dx*dx+dy*dy);
				length+=seg[i];///seg 从1开始 
				Sin[i]=dy/seg[i],Cos[i]=dx/seg[i];
			}
		}
			mid=length/2;
			length=0;
			for(int i=1;i<n;i++){
				if(length+seg[i]>=mid){
					if(length+seg[i]==mid){
						ans_x=node[i].x,ans_y=node[i].y;
						break;
					}
					double temp=length+seg[i]-mid;
					double yy=temp*Sin[i];
					double xx=temp*Cos[i];
					ans_x=node[i].x*1.0-xx,ans_y=node[i].y*1.0-yy;
					break;
				}
				length+=seg[i];
			}
			printf("%.1f %.1f\n",ans_x,ans_y);
		}
	return 0;
}





 [HihoCoder-1697]

思路：直接递归构造。因为先序遍历是 根节点-左子树-右子树，每次找最小的数作为当前子树的根节点，然后根据中序遍历左子树在左边，右子树在右边，先递归遍历左边，再递归遍历右子树。
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=1e6+50;
int node[maxn],n;

void dfs(int l,int r){
	if(l==r) return;
	int t=l;
	for(int i=l;i<r;i++) if(node[i]<node[t]) t=i;
	printf("%d\n",node[t]);
	dfs(l,t);
	dfs(t+1,r);
}

int main(){
	while(scanf("%d",&n)!=EOF){
		memset(node,0,sizeof(node));
		for(int i=0;i<n;i++)
		scanf("%d",&node[i]);
		dfs(0,n);
	}
	return 0;
}



[CodeChef-C3PBR3]



#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1e4+50;;
long long c[maxn][maxn],ans;
int temp[maxn],n;
 
void comb(int nn){
	for(int i=0;i<=nn;i++){
	c[i][0]=1;
	for(int j=1;j<=nn;j++){
		c[i][j]=c[i][j-1]*(i-j+1)/j;
	}		
	}
}
 
int main(){
	while(scanf("%d",&n)!=EOF){
		comb(n);
		memset(temp,0,sizeof(temp));
		ans=0;
		for(int i=0;i<n;i++){
			scanf("%d",&temp[i]);
		}
		sort(temp,temp+n);
		for(int i=0;i<n;i++){
		for(int j=0;j<=min(i,n-i-1);j++){
			ans+=c[i][j]*temp[i]*c[n-i-1][j];
		}	
		}
		printf("%d\n",ans);
	}
	return 0;
}