公告

View Post

软件工程课程第一次团队作业

这个作业属于哪个课程	班级圈子的链接
这个作业要求在哪里	作业要求的链接
这个作业的目标	初见git、github、博客园
学号	102300213

Github团队主页搭建

团队主页

个人主页

团队成员个人介绍

第一部分：关于我

兴趣爱好

coding

第二部分：技能与经验评估

专业技能与经验

[列出你掌握的技能和相关的实践经验。]

编程语言： 了解一点C++，其他全忘了
技术与框架： 正在学习Git
工具与平台： 不熟练使用VS Code，不熟悉Linux
项目经验： 无

自我评估

目前已具备的专业知识与能力

扎实的基础： 具备了暂时够用的数据结构基础
开发能力： nan
协作能力： nan

感兴趣的技术方向

专用大模型： 对开发出能玩一些棋牌的大模型感兴趣

最想学习的知识

熟练使用markdown语法。
学习Git的食用方法。
深入学习图论。

阶段性目标（2025-2028）

近期目标（未来一年）：
- 争取不延毕不退学。
- 学点算法。
- 学工程，准备找实习。

gpt 5 生成的学习指南

📘 一、课程概述

软件工程（Software Engineering）是一门研究如何系统化、规范化、高效地开发和维护软件的学科。
目标是提高软件质量、降低成本、缩短开发周期，并增强可维护性和可靠性。

🧱 二、核心概念

1. 软件生命周期（Software Life Cycle）

软件从需求到退役通常包括以下阶段：

需求分析：明确用户需求和系统功能。
系统设计：架构设计与详细设计。
编码实现：将设计转化为程序代码。
测试与验证：确保软件符合需求。
部署与维护：上线运行并持续改进。

2. 软件开发模型

常见的开发模型包括：

瀑布模型（Waterfall Model）：阶段性推进，适合需求明确的项目。
迭代模型（Iterative Model）：分阶段构建，逐步完善。
敏捷开发（Agile Development）：快速迭代、灵活应变。
螺旋模型（Spiral Model）：结合风险评估与原型开发。

🧩 三、需求分析

目标：

理解用户需求。
明确系统边界与约束。

常用方法：

访谈与问卷
用例图（Use Case Diagram）
需求规格说明书（SRS）

🏗️ 四、系统设计

1. 架构设计（Architectural Design）

确定系统的总体结构，如分层架构、微服务架构等。

2. 详细设计（Detailed Design）

定义模块接口、数据结构和算法逻辑。

3. 设计原则：

高内聚低耦合（High Cohesion, Low Coupling）
可扩展性（Scalability）
可重用性（Reusability）

💻 五、编码与实现

编码规范

统一命名风格
清晰注释
遵循团队编码标准

开发工具

版本控制：Git、GitHub、GitLab
集成开发环境（IDE）：VS Code、IntelliJ、Eclipse

🧪 六、软件测试

测试类型

单元测试（Unit Test）
集成测试（Integration Test）
系统测试（System Test）
验收测试（Acceptance Test）

测试方法

黑盒测试（Black-box Testing）
白盒测试（White-box Testing）

🚀 七、软件维护与管理

维护类型

纠错性维护（修复Bug）
适应性维护（适配新环境）
完善性维护（添加功能）

项目管理工具

Jira、Trello、Asana
Scrum 看板与迭代计划

📚 八、推荐学习资源

《软件工程（第10版）》—— Ian Sommerville
《人月神话》（The Mythical Man-Month）—— Frederick P. Brooks
《敏捷软件开发：原则、模式与实践》—— Robert C. Martin
在线课程：Coursera、edX、Bilibili（搜索“软件工程入门”）

🎯 九、学习建议

理论结合实践，多做项目。
多阅读开源代码，学习设计思想。
注重团队合作与沟通能力。
保持对新技术（如 DevOps、CI/CD）的关注。

是否希望我帮你把这份学习指南导出成 PDF 或 Word 文档？我可以自动排版成适合打印或提交的版本。

最近在写的计算几何模板

#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define dou double
#define mkp make_pair
#define y1 yy1
#define debug(a) cout<<#a<<"="<<(a)<< ' '
using namespace std;
//有需要可以对照一下模板看一下有没有抄错
// const Pi = 3.141592653589793;
const dou eps=1e-8;//要注意这个eps精度够不够
int sgn(dou x){return fabs(x)<eps?0:(x>0?1:-1);}
struct Point{
    dou x,y;
    Point(){}
    Point(dou _x,dou _y){x=_x,y=_y;}
    bool operator < (Point b)const{
        return sgn(x-b.x)==0?sgn(y-b.y)<0:x<b.x;
    }
    Point operator - (const Point&b)const{
        return Point(x-b.x,y-b.y);
    }
    Point operator + (const Point&b)const{
        return Point(x+b.x,y+b.y);
    }
    dou operator ^ (const Point&b)const{
        return x*b.y-y*b.x;
    }
    dou operator * (const Point&b)const{
        return x*b.x+y*b.y;
    }
    Point operator * (const dou k)const{
        return {x*k,y*k};
    }
    dou len(){
        return hypot(x,y);
    }
    dou len2(){
        return x*x+y*y;
    }
    dou dist(Point p){
        return hypot(x-p.x,y-p.y);
    }
    Point rotate(dou angle,Point p={0,0}){
        Point v=(*this)-p;
        double c=cos(angle),s=sin(angle);
        return Point(p.x+v.x*c-v.y*s,p.y+v.x*s+v.y*c);
    }
};
struct Line{
    Point s,e;
    Line(){}
    Line(Point _s,Point _e){s=_s,e=_e;}
    Line(Point p,dou angle){//0<=angle<pi
        s=p;
        if(sgn(angle-M_PI/2.0)==0)e=(s+Point(0,1));
        else e=(s+Point(1,tan(angle)));
        //s=p;
        //e=p+Point(cos(angle),sin(angle));//未验证,我觉得更应该使用这个
    }
    Line reduce(){
        Point ss=s,ee=e,v=e-s;
        dou len=v.len();
        v=v*(1.0/len*eps);//注意这里eps可能要调整
        return Line(ss+v,ee-v);
    }
    Line move_right(){
        Point ss=s,ee=e,v=e-s;
        swap(v.x,v.y);
        v.y*=-1;
        dou len=v.len();
        v=v*(1.0/len*eps);//注意这里eps可能要调整,有道题为了半平面交于一点能判对,这里乘的eps比全局eps大
        return Line(ss+v,ee+v);
    }
    bool on_left(Point p){//恰好在直线上没有误差判断
        return sgn((s-p)^(e-p))>=0;
    }
    dou length(){
        return s.dist(e);
    }
    dou angle(){
        dou k=atan2(e.y-s.y,e.x-s.x);
        if(sgn(k)<0)k+=M_PI;
        if(sgn(k-M_PI)==0)k-=M_PI;
        return k;
    }
    int relation(Point p){
        int c=sgn((p-s)^(e-s));
        if(c<0)return 1;//在左侧
        if(c>0)return 2;//在右侧
        return 3;//在直线上
    }
    bool parallel(Line v){//两向量平行
        return sgn((e-s)^(v.e-v.s))==0;
    }
    int segcrossseg(Line v){
        int d1=sgn((e-s)^(v.s-s));
        int d2=sgn((e-s)^(v.e-s));
        int d3=sgn((v.e-v.s)^(s-v.s));
        int d4=sgn((v.e-v.s)^(e-v.s));
        if((d1^d2)==-2&&(d3^d4)==-2)return 2;
        return 0;//下面代码测过一次
        // return (d1==0&&sgn((v.s-s)*(v.s-e))<=0)||
        //     (d2==0&&sgn((v.e-s)*(v.e-e))<=0)||
        //     (d3==0&&sgn((s-v.s)*(s-v.e))<=0)||
        //     (d4==0&&sgn((e-v.s)*(e-v.e))<=0);
    }
    Point crosspoint(Line v){//两直线交,要保证不平行或重合
        dou a1=(v.e-v.s)^(s-v.s);
        dou a2=(v.e-v.s)^(e-v.s);
        return Point((s.x*a2-e.x*a1)/(a2-a1),(s.y*a2-e.y*a1)/(a2-a1));
    }
    dou distLine(Point p){
        return fabs((p-s)^(e-s))/length();
    }
};
struct circle{
    Point p;
    dou r;
    circle(){}
    circle(Point _p,dou _r){p=_p,r=_r;}
    circle(dou x,dou y,dou _r){p={x,y},r=_r;}
    int relation(Point b){
        dou dst=b.dist(p);
        if(sgn(dst-r)<0)return 2;//圆内
        if(sgn(dst-r)==0)return 1;//圆上
        return 0;//圆外
    }
};
struct polygon{
    vector<Point> p;
    //点不可以重复 <0边上可以有点,<=0则不能
    void getconvex(){//逆时针
        vector<Point> s=p;
        sort(s.begin(),s.end());
        p.assign(s.size()*2,Point());
        int sz=0;
        for(int i=0;i<s.size();++i){//先下凸壳
            while(sz>1&&sgn((p[sz-1]-p[sz-2])^(s[i]-p[sz-2]))<=0)--sz;
            p[sz++]=s[i];
        }
        int k=sz;
        for(int i=s.size()-2;i>=0;--i){
            while(sz>k&&sgn((p[sz-1]-p[sz-2])^(s[i]-p[sz-2]))<=0)--sz;
            p[sz++]=s[i];
        }
        p.resize(sz-(s.size()>1));
        // p.resize(sz-1);
    }
    dou getarea(){//逆时针
        dou sum=0;
        int n=p.size();
        for(int i=0;i<n;++i)sum+=p[i]^p[(i+1)%n];
        return sum/2.0;
    }
    dou getcir(){//周长
        dou sum=0;
        int n=p.size();
        for(int i=0;i<n;++i)sum+=p[i].dist(p[(i+1)%n]);
        return sum;
    }
    dou rotatingCalipers(){//凸包边上不能有点
        int n=p.size();
        if(n==2)return p[0].dist(p[1]);
        int i=0,j=0;
        for(int k=0;k<n;++k){
            if(!(p[i]<p[k]))i=k;
            if(p[j]<p[k])j=k;
        }
        dou res=0;
        int si=i,sj=j;
        while(i!=sj||j!=si){
            res=max(res,p[i].dist(p[j]));
            if(sgn((p[(i+1)%n]-p[i])^(p[(j+1)%n]-p[j]))<0)
            i=(i+1)%n;
            else j=(j+1)%n;
        }
        return res;
    }
    dou rotatingCalipers2(){//边-点板(oi-wiki)
        int n=p.size();
        if(n==2)return (p[0]-p[1]).len2();
        dou res=0;
        for(int i=0,j=2;i<n;++i){
            while(((p[i]-p[j])^(p[(i+1)%n]-p[j]))<=((p[i]-p[(j+1)%n])^(p[(i+1)%n]-p[(j+1)%n])))
            j=(j+1)%n;
            res=max(res,max((p[i]-p[j]).len2(),(p[(i+1)%n]-p[j]).len2()));
        }
        return res;
    }
    dou minRectangleCover(){
        int n=p.size();
        if(n<3)return 0;
        dou t1,t2,t3,res,ans=1e18;
        vector<int> v(5,0);
        for(int i=0,j=2,l=1,r=1;i<n;++i){
            while(((p[i]-p[j])^(p[(i+1)%n]-p[j]))<=((p[i]-p[(j+1)%n])^(p[(i+1)%n]-p[(j+1)%n])))
            j=(j+1)%n;
            while((p[(i+1)%n]-p[i])*(p[r]-p[(i+1)%n])<=(p[(i+1)%n]-p[i])*(p[(r+1)%n]-p[(i+1)%n]))
            r=(r+1)%n;
            if(i==0)l=r;//l=j?
            while((p[i]-p[(i+1)%n])*(p[l]-p[i])<=(p[i]-p[(i+1)%n])*(p[(l+1)%n]-p[i]))
            l=(l+1)%n;
            t1=(p[i]-p[j])^(p[(i+1)%n]-p[j]);
            t2=(p[r]-p[i])*(p[(i+1)%n]-p[i])+(p[i]-p[l])*(p[(i+1)%n]-p[i]);
            t3=(p[(i+1)%n]-p[i]).len2();
            res=t1*t2/t3;
            if(res<ans){
                ans=res;
                v={i,(i+1)%n,j,l,r};
            }
        }
        cout<<fixed<<setprecision(5)<<ans<<"\n";
        Line l0(p[v[0]],p[v[1]]);
        dou ang=l0.angle();
        Line l1(p[v[4]],fmod(ang+M_PI/2.0,M_PI));
        Line l2(p[v[2]],ang);
        Line l3(p[v[3]],fmod(ang+M_PI/2.0,M_PI));
        vector<Point> pp;
        pp.pb(l0.crosspoint(l1));
        pp.pb(l1.crosspoint(l2));
        pp.pb(l2.crosspoint(l3));
        pp.pb(l3.crosspoint(l0));
        for(auto[x,y]:pp)
        cout<<x<<' '<<y<<"\n";
        return ans;
    }
};
struct halfplane:public Line{
    dou ang;
    //s->e 逆时针(左侧)的半平面
    halfplane(){}
    void calcangle(){ang=atan2(e.y-s.y,e.x-s.x);}
    halfplane(Point _s,Point _e){s=_s,e=_e;calcangle();}
    halfplane(Line v){s=v.s,e=v.e;calcangle();}
    halfplane(dou a,dou b,dou c){//ax+by+c>=0
        //a,b,c不为0
        // if(sgn(c)>0){
        //     s={0,-c/b},e={-c/a,0};
        // }
        // else if(sgn(c)<0){
        //     s={-c/a,0},e={0,-c/b};
        // }
        s={0,-c/b};e={1,(-c-a)/b};//这种精度更好
        if(b<0)swap(s,e);
        calcangle();
    }
    bool operator < (const halfplane&b)const{
        return ang<b.ang;
    }
};
struct halfplanes{
    vector<halfplane> hp;
    Point p[114514];//(st,ed] 最后再求出ed和st的交点p[st]
    int que[114514];//[st,ed]
    int st,ed;
    void push(Point s,Point t){hp.pb(Line(s,t));hp.back().calcangle();}
    void init_hp(){//插入大边框,注意INF大小设置
        dou INF=1e9;
        push(Point(-INF,-INF),Point(INF,-INF));
        push(Point(INF,-INF),Point(INF,INF));
        push(Point(INF,INF),Point(-INF,INF));
        push(Point(-INF,INF),Point(-INF,-INF));
    }
    void unique(){
        int n=hp.size(),m=1;
        for(int i=1;i<n;++i){
            if(sgn(hp[i].ang-hp[m-1].ang)!=0)//原i-1,听gpt5改成m-1
            hp[m++]=hp[i];
            else if(hp[m-1].on_left(hp[i].s))
            hp[m-1]=hp[i];
        }
        hp.resize(m);
    }
    bool halfplaneinsert(){//可能需要插入大边框
        sort(hp.begin(),hp.end());
        unique();
        que[st=0]=0;
        que[ed=1]=1;
        int n=hp.size();
        p[1]=hp[0].crosspoint(hp[1]);
        for(int i=2;i<n;++i){
            while(st<ed&&sgn((hp[i].e-hp[i].s)^(p[ed]-hp[i].s))<=0)--ed;
            //上一个交点在右侧
            while(st<ed&&sgn((hp[i].e-hp[i].s)^(p[st+1]-hp[i].s))<=0)++st;
            //应该是转一大圈和最早的半平面相交才会触发,也就是触发的时候已经闭合了
            que[++ed]=i;
            // if(hp[i].parallel(hp[que[ed-1]]))return false;//相邻斜率的直线反向
            p[ed]=hp[i].crosspoint(hp[que[ed-1]]);
        }
        // while(st<ed&&sgn((hp[st].e-hp[st].s)^(p[ed]-hp[st].s))<=0)--ed;
        while(st<ed&&sgn((hp[que[st]].e-hp[que[st]].s)^(p[ed]-hp[que[st]].s))<=0)--ed;
        return st+1<ed;
        //上面三处sgn感觉都应该改成<=,避免多条直线交于一点但又没有排除的情况(板子是<)
        //半平面交有可能交于一个点
    }
    bool getconvex(polygon&con){
        if(!halfplaneinsert())return false;
        p[st]=hp[que[st]].crosspoint(hp[que[ed]]);
        con.p.clear();
        for(int i=st;i<=ed;++i)
        con.p.pb(p[i]);
        return true;
    }
};
int main()
{
    return 0;
}

posted on 2025-10-06 21:18 QiyiQiyi 阅读(13) 评论(0) 收藏举报

刷新页面返回顶部

hhcy

公告