Acy夕拾算法 Week2_day5

LeetCode 322. 零钱兑换

/*
·X贪心X:先取最大的,如果>了再往小取;不行,eg:[1,4,5] 12 ⑤2+①2=4;④*3=3
·dp:通过子问题得到最优解,
·并且题目只问:硬币个数,不需要知道用了哪几个
··类爬楼梯:取到达当前位置的最小
··类完全背包:取最少的物品装满背包
1.确定dp数组以及下标的含义:dp[i]:总金额为i时,需要的最少硬币个数
2.确定递推公式:dp[i] = min( dp[i], dp[i-coins[小于i的]]+1 )
3.dp数组如何初始化:dp[0]=0;取min所以初始化用INT_MAX
4.确定遍历顺序:顺序
*/

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        // if(amount == 0) return 0;
        vector<int> dp(amount+1, INT_MAX);
        dp[0] = 0;
        for(int i = 1; i <= amount; i++)
        {
            for(int j = 0; j < coins.size(); j++)
            {
                if(coins[j] <= i && dp[i-coins[j]] != INT_MAX)
                    dp[i] = min( dp[i], dp[i-coins[j]]+1 );
            }
        }
        return dp[amount]>amount ? -1 : dp[amount];//最小硬币为1,比全为1个数还多,其实是没找到
    }
};

LeetCode 300. 最长递增子序列

/*
删掉重复的、影响增的0,1,2,3;数组不好删除,直接计数
dp取最大的,0-下标 作为一个子问题
1.确定dp数组以及下标的含义:dp[i]:0~i时的最长增序列
2.确定递推公式:dp[i] = max( dp[i], dp[j]+1 )取dp[j] + 1的最大值
3.dp数组如何初始化:dp[0]=1;
4.确定遍历顺序:顺序
*/

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size()+1, 1);
        // dp[0] = 1;
        // dp[1] = 1;
        for(int i = 1; i < nums.size(); i++)
        {
            for(int j = 0; j < i; j++)
            {
                if(nums[i] > nums[j])
                    dp[i] = max(dp[i], dp[j]+1);
            }
        }

        int res = dp[0];
        for(int i = 1; i < dp.size(); i++)
            res = max(res, dp[i]);
        return res;
    }
};
### Java实现Delaunay三角剖分算法 Delaunay三角剖分是一种在二维空间中对点集进行三角化的方法,其核心特性是:任意两个点之间的边不会与其他边相交,并且每个三角形的外接圆内不包含其他点。这种特性使得Delaunay三角剖分广泛应用于计算机图形学、地理信息系统(GIS)等领域。 在Java中实现Delaunay三角剖分,通常可以采用**增量插入法**(Bowyer-Watson算法),该算法通过逐步插入点并删除与新点冲突的三角形来维护Delaunay性质。以下是一个基于该算法的Java实现示例。 --- ### Java代码实现 ```java import java.util.*; class Point { double x, y; Point(double x, double y) { this.x = x; this.y = y; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (!(obj instanceof Point)) return false; Point other = (Point) obj; return Double.compare(other.x, x) == 0 && Double.compare(other.y, y) == 0; } @Override public int hashCode() { return Objects.hash(x, y); } } class Triangle { Point a, b, c; Set<Edge> edges = new HashSet<>(); Triangle(Point a, Point b, Point c) { this.a = a; this.b = b; this.c = c; edges.add(new Edge(a, b)); edges.add(new Edge(b, c)); edges.add(new Edge(c, a)); } boolean circumcircleContains(Point p) { double abx = a.x - b.x; double aby = a.y - b.y; double acx = a.x - c.x; double acy = a.y - c.y; double d = 2 * (abx * (a.y - c.y) - acx * aby); double cx_ = ( (a.x * a.x - b.x * b.x) * (a.y - c.y) - (a.x * a.x - c.x * c.x) * aby ) / d; double cy_ = ( (a.y * a.y - b.y * b.y) * (abx) - (a.y * a.y - c.y * c.y) * acx ) / d; double r = Math.sqrt((a.x - cx_) * (a.x - cx_) + (a.y - cy_) * (a.y - cy_)); double px = p.x - cx_; double py = p.y - cy_; return (px * px + py * py) <= r * r + 1e-8; } } class Edge { Point p1, p2; Edge(Point p1, Point p2) { if (p1.x < p2.x || (p1.x == p2.x && p1.y < p2.y)) { this.p1 = p1; this.p2 = p2; } else { this.p1 = p2; this.p2 = p1; } } @Override public boolean equals(Object obj) { if (this == obj) return true; if (!(obj instanceof Edge)) return false; Edge other = (Edge) obj; return p1.equals(other.p1) && p2.equals(other.p2); } @Override public int hashCode() { return Objects.hash(p1, p2); } } public class DelaunayTriangulation { private static List<Triangle> triangulate(List<Point> points) { List<Triangle> triangles = new ArrayList<>(); Point p1 = new Point(-1000, -1000); Point p2 = new Point(1000, -1000); Point p3 = new Point(0, 1000); Triangle superTriangle = new Triangle(p1, p2, p3); triangles.add(superTriangle); for (Point p : points) { Set<Edge> polygon = new HashSet<>(); List<Triangle> badTriangles = new ArrayList<>(); for (Triangle t : triangles) { if (t.circumcircleContains(p)) { badTriangles.add(t); for (Edge e : t.edges) { boolean shared = false; for (Triangle other : triangles) { if (other != t && other.edges.contains(e)) { shared = true; break; } } if (!shared) { polygon.add(e); } } } } for (Edge e : polygon) { triangles.add(new Triangle(e.p1, e.p2, p)); } triangles.removeAll(badTriangles); } // 移除包含超级三角形顶点的三角形 triangles.removeIf(t -> t.a == p1 || t.a == p2 || t.a == p3 || t.b == p1 || t.b == p2 || t.b == p3 || t.c == p1 || t.c == p2 || t.c == p3); return triangles; } public static void main(String[] args) { List<Point> points = new ArrayList<>(); points.add(new Point(0.0, 0.0)); points.add(new Point(1.0, 0.0)); points.add(new Point(0.5, 1.0)); points.add(new Point(0.5, 0.5)); List<Triangle> result = triangulate(points); for (Triangle t : result) { System.out.println("Triangle: (" + t.a.x + "," + t.a.y + ") - (" + t.b.x + "," + t.b.y + ") - (" + t.c.x + "," + t.c.y + ")"); } } } ``` --- ### 代码说明 - **Point类**:表示二维空间中的点。 - **Edge类**:表示三角形的边,用于边去重。 - **Triangle类**:表示一个三角形,并包含判断点是否在三角形外接圆内的方法。 - **triangulate方法**:使用Bowyer-Watson算法进行增量插入,构建Delaunay三角剖分。 - **main方法**:提供测试点集并输出三角剖分结果。 该实现能够处理任意二维点集,并输出符合Delaunay条件的三角形集合。算法的时间复杂度为O(n&sup2;),适用于中等规模的数据集。 --- ### 性能优化与扩展 对于大规模点集,可以引入**分治法**或**平面扫描法**来提升性能。此外,该算法也可以扩展到三维空间,形成**三维Delaunay三角剖分**(Tetrahedralization),但实现复杂度显著增加[^3]。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值