生成一段实现dijkstra最短路径二次规划的代码。要求自己输入一个无向图，再输入多个起点对应在无向图中的坐标，对每个起点都生成一条最短路径。统计无向图中每条边的使用次数，当无向图中的某条边在多条最短路径中使用次数超过6次，就对经过这条边的一半起点增加这条对应边的权值来达到避开这条边的目的。

好的，这是一个Python实现dijkstra最短路径二次规划的例子：

import heapq

def dijkstra(graph, start):
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    
    queue = []
    heapq.heappush(queue, [distances[start], start])
    
    while queue:
        current_distance, current_node = heapq.heappop(queue)
        
        if current_distance > distances[current_node]:
            continue
        
        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(queue, [distance, neighbor])
    
    return distances

def shortest_paths(graph, start_points):
    paths = {}
    
    for start in start_points:
        paths[start] = dijkstra(graph, start)
    
    return paths

def count_edge_usage(paths):
    edge_counts = {}
    
    for path in paths.values():
        for i in range(len(path)-1):
            edge = frozenset({path[i], path[i+1]})
            if edge in edge_counts:
                edge_counts[edge] += 1
            else:
                edge_counts[edge] = 1
    
    return edge_counts

def adjust_edge_weights(graph, edge_counts):
    for edge, count in edge_counts.items():
        if count > 6:
            node_a, node_b = edge
            weight = graph[node_a][node_b] / 2
            graph[node_a][node_b] = weight
            graph[node_b][node_a] = weight
            
    return graph

# Example usage
graph = {
    'A': {'B': 3, 'C': 5},
    'B': {'A': 3, 'C': 4, 'D': 2},
    'C': {'A': 5, 'B': 4, 'D': 6},
    'D': {'B': 2, 'C': 6}
}

start_points = ['A', 'D']
paths = shortest_paths(graph, start_points)
edge_counts = count_edge_usage(paths)
graph = adjust_edge_weights(graph, edge_counts)

print(graph)

这个例子中，我们首先给出一个无向图（以字典的形式表示），然后给出多个起点（在本例中是'A'和'D'），然后使用dijkstra算法求出每个起点到其它各点的最短路径。接下来，我们统计每条边在最短路径中的使用次数，如果某条边使用次数超过了6次，就将其对应的权重减半。最后，我们输出调整后的无向图。

注意，这个例子并没有输入无向图，需要用户自己通过代码给出。