Algorithm 通过某种度量划分链接对象（如相邻的美国州）的算法？ 用例：在地图上考虑50个美国州，每个州对应于一些成本函数（即市场规模）。是否有一种算法（以及理想的R/Python包）将50个状态划分为N个组，以使每组中代价函数之和的变化最小化？唯一的限制是每个组中的所有状态都是连续的（即，它们形成一个大质量/相互连接）

下面是一些示例代码，说明如何生成所有可能的状态组，最多生成一个合理的数量，技巧是用i的二次方表示第i个状态。一组状态是一个64位整数，其位对应于其状态

data = """AK    WA
AL  FL
AL  GA
AL  MS
AL  TN
AR  LA
AR  MO
AR  MS
AR  OK
AR  TN
AR  TX
AZ  CA
AZ  CO
AZ  NM
AZ  NV
AZ  UT
CA  HI
CA  NV
CA  OR
CO  KS
CO  NE
CO  NM
CO  OK
CO  UT
CO  WY
CT  MA
CT  NY
CT  RI
DC  MD
DC  VA
DE  MD
DE  NJ
DE  PA
FL  GA
GA  NC
GA  SC
GA  TN
IA  IL
IA  MN
IA  MO
IA  NE
IA  SD
IA  WI
ID  MT
ID  NV
ID  OR
ID  UT
ID  WA
ID  WY
IL  IN
IL  KY
IL  MO
IL  WI
IN  KY
IN  MI
IN  OH
KS  MO
KS  NE
KS  OK
KY  MO
KY  OH
KY  TN
KY  VA
KY  WV
LA  MS
LA  TX
MA  NH
MA  NY
MA  RI
MA  VT
MD  PA
MD  VA
MD  WV
ME  NH
MI  OH
MI  WI
MN  ND
MN  SD
MN  WI
MO  NE
MO  OK
MO  TN
MS  TN
MT  ND
MT  SD
MT  WY
NC  SC
NC  TN
NC  VA
ND  SD
NE  SD
NE  WY
NH  VT
NJ  NY
NJ  PA
NM  OK
NM  TX
NM  UT
NV  OR
NV  UT
NY  PA
NY  VT
OH  PA
OH  WV
OK  TX
OR  WA
PA  WV
SD  WY
TN  VA
UT  WY
VA  WV""".splitlines()

edges = [line.split() for line in data]
states = sorted(set([node for pair in edges for node in pair]))
state_map = {}
groups = [set() for _ in range(52)]
neighbours = [[] for _ in range(52)]
for i, state in enumerate(states):
    state_map[state] = i
    state_map[i] = state
    groups[1].add(1 << i)
for a, b in edges:
    i, j = state_map[a], state_map[b]
    neighbours[i].append(j)
    neighbours[j].append(i)

for group_size in range(2, 20):
    prev_groups = groups[group_size-1]
    print "group size: %d, count: %d" % (group_size - 1, len(prev_groups))
    current_groups = groups[group_size]
    for group in prev_groups:
        for i in range(51):
            state = 1 << i
            if state & group == 0:
                for j in neighbours[i]:
                    if group & (1 << j) > 0:
                        current_groups.add(group | (1<<i))
group size: 1, count: 51
group size: 2, count: 111
group size: 3, count: 323
group size: 4, count: 1063
group size: 5, count: 3714
group size: 6, count: 13219
group size: 7, count: 46858
group size: 8, count: 163360
group size: 9, count: 556059
group size: 10, count: 1838076
group size: 11, count: 5873753
group size: 12, count: 18076855
group size: 13, count: 53409207

data=“”AK WA
AL-FL
阿尔加
艾尔质谱
阿尔田
阿拉
阿莫
氩离子质谱
好的
AR-TN
AR TX
阿兹卡
阿兹公司
AZ纳米
阿兹内华达州
亚利桑那大学
你好
内华达州
CA或
科克斯
科恩
钴纳米
好的
输出
CO WY
CT-MA
纽约州
CT RI
DC MD
DC VA
医学博士
新泽西州
德帕
FL GA
GA NC
镓钪
总氮
伊尔
亚锰
伊阿莫
内华达州
IA SD
IA WI
ID MT
ID NV
身份证或
ID UT
艾德瓦
ID WY
白介素
伊尔基
伊尔莫
伊尔维
肯塔基州
在密苏里州
在哦
莫斯
KS NE
KS OK
基摩
基奥
肯塔基州
肯塔基州
KY WV
拉姆斯
德克萨斯州
新罕布什尔州
妈妈
马日
文学硕士
医学博士
弗吉尼亚州医学博士
MD WV
新罕布什尔州
哦
米维
锰钕
MN SD
MN-WI
莫内
莫OK
MO TN
MS TN
钕山
MT SD
怀俄明山
数控加工
北卡罗来纳州
北卡罗来纳州
ND SD
东北SD
东北怀俄明州
新罕布什尔州
纽约州
新泽西州
NM OK
纳米发射
纳米UT
内华达州
内华达州
宾夕法尼亚州纽约
纽约
哦，爸爸
哦，WV
OK TX
或WA
帕·沃夫
SD WY
田纳西州
威斯康星州
VA WV”“。拆分线（）
edges=[line.split（）表示数据中的行]
状态=已排序（设置（[node for pair for pair for node in pair for node in Edge]））
状态映射={}
groups=[set（）表示范围内的uu（52）]
邻域=[]表示范围内的[52]
对于i，在枚举中列出（状态）：
状态映射[状态]=i
状态映射[i]=状态
组[1]。添加（1有一个相关的问题，搜索空间较小，可能更容易处理，或者至少更容易编码。给定N个组，选择N个状态并将它们称为根。将状态划分为多个组的一种方法是说，与根相关联的组是与此根比任何其他根更接近的状态集。允许o对此进行微调，每个根都有一个常数K，并根据到根的距离和该根的常数K之和划分状态

以这种方式创建的组总是由连续的状态组成，因为如果一个状态在一个组中，则从该状态到该组根的最短路径上的所有状态也在该组中。如果其中一个状态不在该组中，则该状态到另一个根的路径将更短，这意味着原始状态也将在该组中通过中间状态到不同根的路径更短，这是一个矛盾

这仍然不是一个容易处理的问题，但是你可以调用常数上的爬山来尝试平衡分配，你可以选择根来爬山。如果你从多个随机开始爬山，你可以希望得到一些不错的答案，并且你可能希望了解到目前为止你在厕所看到的最好答案有多好其他山顶的金发现——如果最好的答案出现多次，我会很乐观

下面是一些Java，由于对主体的限制，注释被修剪


import java.util.ArrayList;
import java.util.Arrays;
import java.awt.BorderLayout;
import java.io.BufferedReader;
import java.util.Collections;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.io.File;
import java.io.FileReader;
import java.awt.Graphics;
import java.util.HashMap;
import java.util.HashSet;
import java.io.IOException;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.awt.Rectangle;
import javax.swing.SwingUtilities;

public class States
{
  /** Info held for State */
  private static class StateInfo
  {
    private final String m_name;
    /** abbreviation of state - drawn on graph */
    private final String m_abbreviation;
    private final double m_latitudeDegrees;
    private final double m_longitudeDegrees;
    private int m_currentX;
    private int m_currentY;
    /** 0-up number allocated and offset in ArrayList */
    private final int m_number;
    /** link to neighbouring states */
    private final ArrayList m_neighbours =
      new ArrayList();
    /** colour to print in. Modified when states are grouped */
    private Color m_color = Color.BLACK;
    /** weight when computing variance */
    private double m_weight = 1.0;
    public String toString()
    {
      StringBuilder sb = new StringBuilder();
      sb.append(m_abbreviation + " color " + m_color);
      return sb.toString();
    }
    public StateInfo(String name, String abbreviation,
      double latitudeDegrees, double longitudeDegrees, int number)
    {
      m_name = name;
      m_abbreviation = abbreviation;
      m_latitudeDegrees = latitudeDegrees;
      m_longitudeDegrees = longitudeDegrees;
      m_number = number;
    }
    public double getLatitudeDegrees()
    {
      return m_latitudeDegrees;
    }
    public double getLongitudeDegrees()
    {
      return m_longitudeDegrees;
    }
    public String getAbbreviation()
    {
      return m_abbreviation;
    }
    public void addNeighbour(StateInfo si)
    {
      m_neighbours.add(si);
    }
    public List getNeighbours()
    {
      return Collections.unmodifiableList(m_neighbours);
    }
    public void setCurrentPos(int x, int y)
    {
      m_currentX = x;
      m_currentY = y;
    }
    public int getX()
    {
      return m_currentX;
    }
    public int getY()
    {
      return m_currentY;
    }
    public int getNumber()
    {
      return m_number;
    }
    public Color getColor()
    {
      return m_color;
    }
    public void setColor(Color newValue)
    {
      m_color = newValue;
    }
    public double getWeight()
    {
      return m_weight;
    }
    public void setWeight(double newValue)
    {
      m_weight = newValue;
    }
  }
  public static class StatePanel extends JPanel
  {
    @Override
    public void paint(Graphics g)
    {
      Rectangle rect = getBounds();
      double minLat = Double.MAX_VALUE;
      double maxLat = -Double.MAX_VALUE;
      double minLon = Double.MAX_VALUE;
      double maxLon = -Double.MAX_VALUE;
      for (StateInfo si: m_stateInfo)
      {
        double lat = si.getLatitudeDegrees();
        double lon = si.getLongitudeDegrees();
        if (lat  maxLat)
        {
          maxLat = lat;
        }
        if (lon  maxLon)
        {
          maxLon = lon;
        }
      }
      int numStates = m_stateInfo.size();
      double gapAdd = 1.0 / (double)(numStates + 1);
      double gapFactor = (numStates - 1) / (double)(numStates + 1);
      for (StateInfo si: m_stateInfo)
      {
        double x = (si.getLongitudeDegrees() - minLon) / (maxLon - minLon);
        x = x * gapFactor + gapAdd;
        double y = (maxLat - si.getLatitudeDegrees()) / (maxLat - minLat);
        y = y * gapFactor + gapAdd;
        int xpos = (int)Math.round(rect.x + x * rect.width);
        int ypos = (int)Math.round(rect.y + y * rect.height);
        g.setColor(si.getColor());
        g.drawString(si.getAbbreviation(), xpos, ypos);
        si.setCurrentPos(xpos, ypos);
      }
      g.setColor(Color.BLACK);
      for (StateInfo si: m_stateInfo)
      {
        int xp = si.getX();
        int yp = si.getY();
        for (StateInfo ti: si.getNeighbours())
        { 
          if (si.getNumber()  rows = new ArrayList();
        for (;;)
        {
          String line = br.readLine();
          if (line == null)
          {
            break;
          }
          int len = line.length();
          int l1 = len - 1;
          ArrayList cells = new ArrayList();
          StringBuilder currentCell = new StringBuilder();
          for (int i = 0; i = l1)
              {
                throw new IllegalArgumentException("Unterminated quote in line " + line);
              }
              ch = line.charAt(++i);
              if (ch != '"')
              {
                currentCell.append(ch);
                continue;
              }
              if ((i >= l1) || (line.charAt(i + 1) != '"'))
              {
                break;
              }
              currentCell.append(ch);
              i++;
            }
          }
          if (len > 0)
          {
            cells.add(currentCell.toString());
          }
          String[] row = new String[cells.size()];
          row = cells.toArray(row);
          rows.add(row);
        }
        String[][] result = new String[rows.size()][];
        result = rows.toArray(result);
        return result;
      }
      finally
      {
        fr.close();
      }
    }
    /** Read locations of states and links between them from file */
    public void readLocations(String filename, String linkFile) throws Exception
    {
      // First two lines of file are
      // # State,Latitude,Longitude,Abbreviation,Population
      // Alabama,32.806671,-86.79113,AL,4.859
      // Population is in millions. File is result of hand-editing together info from web
      String[][] data = readCsv(new File(filename));
      m_stateInfo = new ArrayList();
      m_stateInfoByAbbreviation = new HashMap();
      int num = 0;
      for (String[] row: data)
      {
        if (row.length  rootOffsetByColor = new HashMap();
      for (int i = 0; i  reducedWeights[i])
          {
            reducedWeights[i] = reduced;
          }
        }
        if (secondBest  totalByColor = new HashMap();
      for (;;)
      {
        allocateViaDistance(m_roots, initialWeights, m_colors);
        double varianceHere = getVariance(totalByColor);
        double total = 0.0;
        for (Double d: totalByColor.values())
        {
          total += d.doubleValue();
        }
        double target = total / m_roots.length;
        minimumNecessary(m_roots, initialWeights, m_colors, decrease, increase);
        boolean improved = false;
        // Don't need to change weight[0] as we can regard everything else as
        // compared to that as a standard
        for (int i = 1; i  totalByColor)
    {
      totalByColor.clear();
      for (StateInfo si: m_stateInfo)
      {
        Color key = si.getColor();
        Double d = new Double(0.0);
        if (totalByColor.containsKey(key))
        {
          d = totalByColor.get(key);
        }
        totalByColor.put(key, new Double(d.doubleValue() + si.getWeight()));
      }
      int numUsed = totalByColor.size();
      if (numUsed  totalByColor = new HashMap();
      return getVariance(totalByColor);
    }
    public StateInfo getState(String abbreviation)
    {
      return m_stateInfoByAbbreviation.get(abbreviation);
    }
    public void setColorsRoots(Color[] colors, StateInfo[] roots)
    {
      m_roots = roots;
      m_colors = colors;
    }
    public StateInfo[] getRoots()
    {
      return m_roots;
    }
    public double climbRoots(double[] weights)
    {
      for (;;)
      {
        double current = getVariance();
        boolean improved = false;
        for (int i = 0; i  chosen = new HashSet();
        m_roots = new StateInfo[weights.length];
        for (int j = 0; j  m_stateInfo;
    private Map m_stateInfoByAbbreviation;
    private double[][] m_distances;
    private StateInfo[] m_roots;
    private Color[] m_colors;
  }
  /** compute all-pairs distances (Floyd - Warshall) */
  public static void allPairs(double[][] distances)
  {
    int pass = 0;
    for (boolean changed = true; changed;)
    {
      changed = false;
      System.err.println("Pass " + (pass++));
      for (int i = 0; i  totalByColor = new HashMap();
            var = sp.getVariance(totalByColor);
            System.out.println("Multiple start Climbed to variance " + var);
            System.out.println("Roots " + Arrays.toString(sp.getRoots()));
            System.out.println("Totals " + totalByColor.values());
          }
          System.out.println("Allocated result is " + sp.getVariance());
        }
        catch (Exception ex)
        {
          System.err.println("Exception setting up: " + ex);
          ex.printStackTrace();
          return;
        }
        sp.setPreferredSize(new Dimension(400, 400));
        JFrame w = new JFrame();
        w.setTitle("States");
        Container cp = w.getContentPane();
        cp.setLayout(new BorderLayout());
        cp.add(sp, BorderLayout.CENTER);
        w.pack();
        w.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        w.setVisible(true);
      }
    };
    SwingUtilities.invokeAndWait(r);
  }
}

很可能是NP完全的，可以很容易地简化设置分区、装箱、背包或其他东西。你可能可以使用已知的启发式方法，比如大致按大小降序将状态划分为组，以获得一个好的但不是最优的结果。谢谢你的回答。我不确定这是否考虑到iGuus状态约束这也可能有帮助：